/**
* Vue v3.5.13
*（c）2018 年至今 Yuxi (Evan) You 和 Vue 贡献者
*@license MIT
**/
var Vue = (函数(导出) {
  ‘严格使用’；

  /*!#__无副作用__*/
  //@__无副作用__
  函数 makeMap (str) {
    const map = /* @__PURE__ */ Object.create(null);
    对于（str.split（“，”）的const key）map [key] = 1；
    返回（val）=> 映射中的val；
  }

  复制代码
  const EMPTY_ARR = Object.freeze([]) ;
  const NOOP = () => {
  };
  const NO = () => false;
  const isOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && // 大写字母
  （key.charCodeAt（2）> 122 || key.charCodeAt（2）<97）；
  const isModelListener = (key) => key.startsWith("onUpdate:");
  const 扩展 = 对象.assign;
  const 删除 = (arr，el) => {
    const i = arr.indexOf(el);
    如果（i> -1）{
      arr. 拼接（i， 1）；
    }
  };
  const hasOwnProperty$1 = Object.prototype.hasOwnProperty;
  const hasOwn = (val，key) => hasOwnProperty$1.call(val，key);
  复制代码
  const isMap = (val) => toTypeString(val) ===“[object Map]”;
  const isSet = (val) => toTypeString(val) ===“[对象集]”;
  const isDate = (val) => toTypeString(val) ===“[object Date]”;
  const isRegExp = (val) => toTypeString(val) ===“[object RegExp]”;
  const isFunction = (val) => typeof val === “函数”;
  const isString = (val) => typeof val === “string”;
  const isSymbol = (val) => typeof val === “符号”;
  const isObject = (val) => val !== null && typeof val === “object”;
  const isPromise = (val) => {
    返回 (isObject(val) || isFunction(val)) && isFunction(val.then) && isFunction(val.catch);
  };
  const objectToString = Object.prototype.toString;
  const toTypeString = (值) => objectToString.call(值);
  const toRawType = (值) => {
    返回TypeString(value).slice(8, -1);
  };
  const isPlainObject = (val) => toTypeString(val) ===“[object Object]”;
  const isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
  const isReservedProp = /* @__PURE__ */ makeMap(
    // 前导逗号是故意的，因此也包括空字符串“”
    ",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"
  （英文）：
  const isBuiltInDirective = /* @__PURE__ */ makeMap(
    “绑定、披风、否则，如果、否则、对于、html、如果、模型、开启、一次、预、显示、插槽、文本、备忘录”
  （英文）：
  const cacheStringFunction = (fn) => {
    const 缓存 = /* @__PURE__ */ Object.create(null);
    返回 (str) => {
      const hit = 缓存[str];
      返回命中 || (cache[str] = fn(str));
    };
  };
  const camelizeRE = /-(\w)/g;
  const camelize = cacheStringFunction（
    (字符串) => {
      return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
    }
  （英文）：
  const 连字符RE = /\B([AZ])/g;
  const hyphenate = cacheStringFunction（
    （str）=> str.replace（hyphenateRE，“-$1”）。toLowerCase（）
  （英文）：
  const capitalize = cacheStringFunction((str) => {
    返回 str.charAt(0).toUpperCase() + str.slice(1);
  });
  const toHandlerKey = cacheStringFunction（
    (字符串) => {
      const s = str ? `on${capitalize(str)}` : ``;
      返回 s；
    }
  （英文）：
  const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
  constinvokeArrayFns = (fns，...arg) => {
    对于（让 i = 0；i < fns.length；i++）{
      fns[i](...arg);
    }
  };
  const def = (obj, key, value, writable = false) => {
    Object.defineProperty（obj，key，{
      可配置： true，
      可枚举：false，
      可写，
      价值
    });
  };
  const looseToNumber = (val) => {
    const n = 解析Float（val）；
    返回 isNaN(n) ? val : n;
  };
  const toNumber = (val) => {
    const n = isString(val) ？数字（val）：NaN；
    返回 isNaN(n) ? val : n;
  };
  让 _globalThis；
  const getGlobalThis = () => {
    返回 _globalThis || (_globalThis = typeof globalThis !== “undefined” ? globalThis : typeof self !== “undefined” ? self : typeof window !== “undefined” ? window : typeof global !== “undefined” ? global : {});
  };
  函数 genCacheKey (源，选项) {
    返回源 + JSON.stringify(
      选项，
      (_，val) => typeof val === “函数”？val.toString()：val
    （英文）：
  }

  const PatchFlagNames = {
    [1]：`文本`，
    [2]：`班级`，
    [4]：`风格`，
    [8]: `道具`,
    [16]: `FULL_PROPS`，
    [32]：`需要补水`，
    [64]：`STABLE_FRAGMENT`，
    [128]：`KEYED_FRAGMENT`，
    [256]：`UNKEYED_FRAGMENT`，
    [512]：`需要补丁`，
    [1024]：`DYNAMIC_SLOTS`，
    [2048]：`DEV_ROOT_FRAGMENT`，
    [-1]: `已提升`，
    [-2]：`保释`
  };

  const slotFlagsText = {
    [1]：“稳定”，
    [2]：“动态”，
    [3]：“已转发”
  };

  const GLOBALS_ALLOWED = "Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console,Error,Symbol";
  const isGloballyAllowed = /* @__PURE__ */ makeMap(GLOBALS_ALLOWED);

  常量范围 = 2;
  函数generateCodeFrame（源，开始=0，结束=源.长度）{
    开始 = Math.max(0，Math.min(开始，源.长度));
    结束 = Math.max(0，Math.min(结束，源.长度));
    如果（开始 > 结束）则返回“”；
    让行 = 源.split(/(\r?\n)/);
    const newlineSequences = lines.filter((_，idx) => idx % 2 === 1);
    线条 = 线条.过滤器（（_，idx）=> idx％2 === 0）；
    让计数=0；
    const res = [];
    对于（让 i = 0; i < lines.length; i++）{
      计数 += 行[i].长度 + (newlineSequences[i] && newlineSequences[i].长度 || 0);
      如果 (计数 >= 开始) {
        对于（让 j = i - 范围；j <= i + 范围 || 结束 > 计数；j++）{
          如果 (j < 0 || j >= lines.length) 则继续；
          const 线 = j + 1;
          res.推送（
            `${line}${" ".repeat(Math.max(3 - String(line).length, 0))}| ${lines[j]}`
          （英文）：
          const 线长 = 线[j].长度;
          const newLineSeqLength = newlineSequences[j] && newlineSequences[j].length || 0;
          如果 (j === i) {
            const pad = 开始 - （计数 - （lineLength + newLineSeqLength））；
            const 长度 = Math.max(
              1、
              结束 > 计数 ? 行长 - 填充 : 结束 - 开始
            （英文）：
            res.push(` | ` + " ".repeat(pad) + "^".repeat(length));
          } 否则，如果 (j > i) {
            如果 (结束 > 计数) {
              const 长度 = Math.max(Math.min(结束 - 计数， 行长), 1);
              res.push(` | ` + "^".repeat(length));
            }
            计数 += 行长度 + 新行序列长度；
          }
        }
        休息;
      }
    }
    返回 res.join("\n");
  }

  函数 normalizeStyle (值) {
    如果 (isArray (值)) {
      常量 res = {};
      对于（让 i = 0；i < 值.长度；i++）{
        const 项目 = 值[i];
        const normalized = isString（item）？parseStringStyle（item）：normalizeStyle（item）；
        如果（规范化）{
          for（标准化的 const 键）{
            res[键] = 标准化[键];
          }
        }
      }
      返回 res；
    } 否则，如果 (isString (值) || isObject (值)) {
      返回值；
    }
  }
  const listDelimiterRE = /;(?![^(]*\))/g;
  const propertyDelimiterRE = /:([^]+)/;
  const styleCommentRE = /\/\*[^]*?\*\//g;
  函数 parseStringStyle(cssText) {
    常量 ret = {};
    cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => {
      如果（项目）{
        const tmp = item.split(propertyDelimiterRE);
        tmp.长度 > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
      }
    });
    返回 ret；
  }
  函数 stringifyStyle(样式) {
    如果（！styles）返回“”；
    如果（isString（styles））返回样式；
    让 ret = "";
    for（样式中的 const 键）{
      const 值 = 样式[key];
      如果（isString（值）|| typeof 值 ===“number”）{
        const normalizedKey = key.startsWith(`--`) ? key : 连字符(key);
        ret += `${normalizedKey}:${value};`;
      }
    }
    返回 ret；
  }
  函数 normalizeClass(值) {
    让 res = "";
    如果 (isString (值)) {
      res = 值；
    } 否则，如果 (isArray (值)) {
      对于（让 i = 0；i < 值.长度；i++）{
        const normalized = normalizeClass(值[i]);
        如果（规范化）{
          res += 标准化 + " ";
        }
      }
    } 否则，如果 (isObject(值)) {
      for (const 名称 in 值) {
        如果 (值 [名称]) {
          res += 名称 + “ “;
        }
      }
    }
    返回 res.trim()；
  }
  函数 normalizeProps (props) {
    如果（！props）返回null；
    让 { class：klass，style } = props；
    if (klass && !isString(klass)) {
      props.class = normalizeClass(klass);
    }
    如果（样式）{
      props.style = normalizeStyle(风格);
    }
    返还道具；
  }

  const HTML_TAGS = "html,body,base,head,link,meta,style,title,address,article,aside,footer,header,hgroup,h1,h2,h3,h4,h5,h6,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,区域、音频、地图、轨道、视频、嵌入、对象、参数、源、画布、脚本、无脚本、del、ins、标题、col、colgroup、表格、thead、tbody、td、th、tr、按钮、数据列表、字段集、表格、输入、标签、图例、仪表、optgroup、选项、输出、进度、选择、文本区域、详细信息、对话框、菜单、摘要、模板、blockquote、iframe、tfoot”；
  const SVG_TAGS = "svg,动画,animateMotion,animateTransform,圆圈,clipPath,颜色配置文件,defs,desc,丢弃,椭圆,feBlend,feColorMatrix,feComponentTransfer,feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,feDistantLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology ,feOffset,fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,过滤器,foreignObject,g,hatch,hatchpath,图像,线,linearGradient,标记,蒙版,网格,meshgradient,meshpatch,meshrow,元数据,mpath,路径,图案,多边形,折线,radialGradient,rect,设置,solidcolor,停止,开关,符号,文本,textPath,标题,tspan,未知,使用,查看";
  const MATH_TAGS = "注释，注释-xml，maction，maligngroup，malignmark，math，menclose，merror，mfenced，mfrac，mfraction，mglyph，mi，mlabeledtr，mlongdiv，mmultiscripts，mn，mo，mover，mpadded，mphantom，mprescripts，mroot，mrow，ms，mscarries，mscarry，msgroup，msline，mspace，msqrt，msrow，mstack，mstyle，msub，msubsup，msup，mtable，mtd，mtext，mtr，munder，munderover，none，语义"；
  const VOID_TAGS = "区域、基础、br、col、嵌入、hr、img、输入、链接、元、参数、源、轨道、wbr";
  const isHTMLTag = /* @__PURE__ */ makeMap(HTML_TAGS);
  const isSVGTag = /* @__PURE__ */ makeMap(SVG_TAGS);
  const isMathMLTag = /* @__PURE__ */ makeMap(MATH_TAGS);
  const isVoidTag = /* @__PURE__ */ makeMap(VOID_TAGS);

  const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
  const isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs);
  const isBooleanAttr = /* @__PURE__ */ makeMap(
    specialBooleanAttrs + `，异步，自动对焦，自动播放，控制，默认，延迟，禁用，隐藏，惰性，循环，打开，必需，反转，范围，无缝，选中，静音，多个，选定`
  （英文）：
  函数 includeBooleanAttr（值）{
    返回 !!value || value === "";
  }
  const isKnownHtmlAttr = /* @__PURE__ */ makeMap(
    `接受、接受字符集、访问键、操作、对齐、允许、alt、异步、自动大写、自动完成、自动对焦、自动​​播放、背景、背景颜色、边框、缓冲、捕获、挑战、字符集、已检查、引用、类、代码、代码库、颜色、cols、colspan、内容、contenteditable、上下文菜单、控件、坐标、跨源、csp、数据、日期时间、解码、默认、延迟、dir、dirname、已禁用、下载、可拖动、dropzone、enctype、enterkeyhint、for、表格、formaction、formenctype、formmethod、formnovalidate、formtarget、标题、高度、隐藏、高、href、hr eflang,http-equiv,icon,id,importance,inert,integrity,ismap,itemprop,keytype,kind,label,lang,language,loading,list,loop,low,manifest,max,maxlength,minlength,media,min,multiple,muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,referrerpolicy,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,selected,shape,size,sizes,slot,span,spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,target,title,translate,type,usemap,value,width,wrap`
  （英文）：
  const isKnownSvgAttr = /* @__PURE__ */ makeMap(
    `xmlns、重音高度、累积、附加、对齐基线、字母、振幅、阿拉伯形式、上升、属性名称、属性类型、方位角、基频、基线偏移、baseProfile、bbox、开始、偏差、通过、计算模式、大写字母高度、类、剪辑、clipPathUnits、剪辑路径、剪辑规则、颜色、颜色插值、颜色插值过滤器、颜色配置文件、颜色 r endering、contentScriptType、contentStyleType、crossorigin、光标、cx、cy、d、减速、下降、diffuseConstant、方向、显示、除数、显性基线、dur、dx、dy、edgeMode、海拔、启用背景、结束、指数、填充、填充不透明度、填充规则、过滤器、filterRes、filterUnits、洪水颜色、洪水不透明度、字体系列、字体大小、字体大小调整、字体-stretch、字体样式、字体变体、字体粗细、格式、来自、fr、fx、fy、g1、g2、字形名称、字形水平方向、字形垂直方向、glyphRef、gradientTransform、gradientUnits、悬挂、高度、href、hreflang、horiz-adv-x、horiz-origin-x、id、表意、图像渲染、in、in2、截距、k、k1、k2、k3、k4、kernelMatrix、kernelUnitLength、kerning、关键点、关键样条线、关键时间、语言、长度调整、字母间距、灯光颜色、限制锥角、局部、标记结束、标记中间、标记开始、标记高度、标记单位、标记宽度、掩码、掩码内容单位、掩码单位、数学、最大值、媒体、方法、最小值、模式、名称、numOctaves、偏移、不透明度、运算符、顺序、方向、方向、原点、溢出、上线 po位置、上线厚度、全景图-1、绘制顺序、路径、路径长度、模式内容单位、模式变换、模式单位、ping、指针事件、点、pointsAtX、pointsAtY、pointsAtZ、保留Alpha、保留纵横比、原始单位、r、半径、referrerPolicy、refX、refY、rel、渲染意图、重复计数、重复持续时间、必需扩展、必需特征、休息艺术、结果、旋转、rx、ry、比例、种子、形状渲染、斜率、间距、镜面反射常数、镜面反射指数、速度、扩展方法、起始偏移、标准偏差、stemh、stemv、stitchTiles、停止颜色、停止不透明度、删除线位置、删除线厚度、字符串、描边、描边虚线数组、描边虚线偏移、描边线帽、描边线连接、描边斜接限制，笔触不透明度、笔触宽度、样式、表面比例、系统语言、tabindex、tableValues、目标、targetX、targetY、文本锚点、文本装饰、文本渲染、textLength、到、变换、变换原点、类型、u1、u2、下划线位置、下划线粗细、unicode、unicode-bidi、unicode-range、单位/em、v-字母、v-悬挂、v-表意、v-数学cal、值、矢量效果、版本、垂直 adv-y、垂直原点 x、垂直原点 y、viewBox、viewTarget、可见性、宽度、宽度、字间距、书写模式、x、x 高度、x1、x2、xChannelSelector、xlink：actuate、xlink：arcrole、xlink：href、xlink：role、xlink：show、xlink：title、xlink：type、xmlns：xlink、xml：base、xml：lang、xml：space、y、y1、y2、yChannelSelector、z、zoomAndPan`
  （英文）：
  函数 isRenderableAttrValue (值) {
    如果 (值 == null) {
      返回 false；
    }
    const 类型 = 值的类型；
    返回类型 ===“字符串”|| 类型 ===“数字”|| 类型 ===“布尔值”；
  }

  const cssVarNameEscapeSymbolsRE = /[ !"#$%&'()*+,./:;<=>?@[\\\]^`{|}~]/g;
  函数 getEscapedCssVarName (key，doubleEscape) {
    返回键.replace（
      cssVarNameEscapeSymbolsRE，
      （s）=>`\\${s}`
    （英文）：
  }

  函数 looseCompareArrays(a，b) {
    如果 (a.length !== b.length) 返回 false;
    让相等 = true;
    对于（让 i = 0; 相等 && i < a.length; i++）{
      相等 = 松散相等（a[i]，b[i]）；
    }
    返回相等；
  }
  函数 looseEqual(a，b) {
    如果 (a === b) 返回 true；
    让 aValidType = isDate(a);
    让 bValidType = isDate(b);
    如果 (aValidType || bValidType) {
      返回 aValidType && bValidType ? a.getTime() === b.getTime() : false;
    }
    aValidType = isSymbol(a);
    bValidType = 是符号 (b);
    如果 (aValidType || bValidType) {
      返回 a === b;
    }
    aValidType = isArray(a);
    bValidType = isArray(b);
    如果 (aValidType || bValidType) {
      返回 aValidType && bValidType ? looseCompareArrays(a, b) : false;
    }
    aValidType = isObject(a);
    bValidType = isObject(b);
    如果 (aValidType || bValidType) {
      如果 (!aValidType || !bValidType) {
        返回 false；
      }
      const aKeysCount = Object.keys(a).length;
      const bKeysCount = Object.keys(b).length;
      如果 (aKeysCount !== bKeysCount) {
        返回 false；
      }
      for (a 中的 const 键) {
        声明一个 key 属性，然后设置它的值。
        const bHasKey = b.hasOwnProperty(key);
        if (aHasKey && !bHasKey || !aHasKey && bHasKey || !looseEqual(a[key], b[key])) {
          返回 false；
        }
      }
    }
    返回 String(a) === String(b);
  }
  函数 looseIndexOf(arr，val) {
    返回 arr.findIndex((item) => looseEqual(item, val));
  }

  const isRef$1 = (val) => {
    返回！（val && val["__v_isRef"] === true）；
  };
  const toDisplayString = (val) => {
    返回 isString(val) ? val : val == null ? "" : isArray(val) || isObject(val) && (val.toString === objectToString || !isFunction(val.toString)) ? isRef$1(val) ? toDisplayString(val.value) : JSON.stringify(val, replacer, 2) : String(val);
  };
  const replacer = (_key, val) => {
    如果（isRef$1（val））{
      返回 replacer（_key，val.value）；
    } 否则，如果 (isMap(val)) {
      返回 {
        [`Map(${val.size})`]: [...val.entries()].reduce(
          (entries, [key, val2], i) => {
            条目[stringifySymbol(key，i) +" =>"] = val2;
            返回条目；
          }，
          {}
        ）
      };
    } 否则，如果 (isSet(val)) {
      返回 {
        [`设置（${val.size}）`]：[...val.values（）].map（（v）=> stringifySymbol（v））
      };
    } 否则，如果 (isSymbol(val)) {
      返回 stringifySymbol（val）；
    } 否则，如果 (isObject(val) && !isArray(val) && !isPlainObject(val)) {
      返回字符串（val）；
    }
    返回值；
  };
  const stringifySymbol = (v, i = "") => {
    var _a;
    返回 （
      // es2019+ 中的 Symbol.description 因此我们需要在这里进行强制转换才能通过
      // lib: es2016 检查
      是符号（v）？`符号（${（_a = v.description）！= null？_a：i}）`：v
    （英文）：
  };

  函数警告$2（msg，...args）{
    console.warn(`[Vue warn] ${msg}`, ...args);
  }

  让 activeEffectScope；
  类 EffectScope {
    构造函数（分离 = false）{
      这个.分离 = 分离;
      /**
       * @内部的
       */
      这个._active = true;
      /**
       * @内部的
       */
      这个.效果 = [];
      /**
       * @内部的
       */
      这个.清理 = [];
      这个。_isPaused = false;
      这个.parent = activeEffectScope;
      如果 (!分离 && activeEffectScope) {
        this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(
          这
        ）-1；
      }
    }
    激活（）{
      返回这个。_active；
    }
    暂停（） {
      如果（这个._active）{
        这个。_isPaused = true;
        让 i，l；
        如果（这个.范围）{
          对于（i = 0，l = this.scopes.length; i < l; i++）{
            这个.范围[i].暂停()；
          }
        }
        对于（i = 0，l = this.effects.length; i < l; i++）{
          这个.效果[i].暂停();
        }
      }
    }
    /**
     * 恢复效果范围，包括所有子范围和效果。
     */
    恢复（） {
      如果（这个._active）{
        如果（this._isPaused）{
          这个。_isPaused = false;
          让 i，l；
          如果（这个.范围）{
            对于（i = 0，l = this.scopes.length; i < l; i++）{
              这个.范围[i].恢复（）；
            }
          }
          对于（i = 0，l = this.effects.length; i < l; i++）{
            这个.effects[i].resume()；
          }
        }
      }
    }
    运行（fn）{
      如果（这个._active）{
        const currentEffectScope = activeEffectScope;
        尝试 {
          activeEffectScope = 这个；
          返回 fn()；
        } 最后 {
          活动效果作用域 = 当前效果作用域；
        }
      } 别的 {
        warn$2(`无法运行非活动效果范围。`);
      }
    }
    /**
     * 这只能在非分离范围内调用
     * @内部的
     */
    在（） {
      activeEffectScope = 这个；
    }
    /**
     * 这只能在非分离范围内调用
     * @内部的
     */
    离开（） {
      activeEffectScope = 这个.parent;
    }
    停止（来自父级）{
      如果（这个._active）{
        这个._active = false;
        让 i，l；
        对于（i = 0，l = this.effects.length; i < l; i++）{
          这个.效果[i].停止();
        }
        这个.效果.长度 = 0;
        对于（i = 0，l = this.cleanups.length; i < l; i++）{
          这个.cleanups[i]()；
        }
        这个.清理.长度 = 0;
        如果（这个.范围）{
          对于（i = 0，l = this.scopes.length; i < l; i++）{
            这个.范围[i].停止（true）；
          }
          这个.范围.长度 = 0;
        }
        如果 (!此.detached && 此.parent && !fromParent) {
          const last = this.parent.scopes.pop();
          如果 (最后 && 最后 !== 这个) {
            这个.父.范围[这个.索引] = 最后;
            最后一个索引 = 这个索引；
          }
        }
        这个.父级 = void 0;
      }
    }
  }
  函数效果作用域（分离）{
    返回新的 EffectScope(detached);
  }
  函数 getCurrentScope() {
    返回 activeEffectScope；
  }
  函数 onScopeDispose（fn，failSilently = false）{
    如果 (activeEffectScope) {
      activeEffectScope.cleanups.push(fn);
    } 否则，如果（！failSilently）{
      警告$2(
        当没有与之关联的活动效果范围时，将调用 `onScopeDispose()。`
      （英文）：
    }
  }

  让 activeSub；
  const pausedQueueEffects = /* @__PURE__ */ new WeakSet();
  类 ReactiveEffect {
    构造函数（fn）{
      这个.fn = fn;
      /**
       * @内部的
       */
      这个.deps = void 0;
      /**
       * @内部的
       */
      这个.depsTail = void 0;
      /**
       * @内部的
       */
      这个.标志 = 1 | 4;
      /**
       * @内部的
       */
      这个.下一个= void 0;
      /**
       * @内部的
       */
      这个.清理 = void 0;
      这个.调度程序 = void 0;
      如果 (activeEffectScope && activeEffectScope.active) {
        activeEffectScope.effects.push（这个）；
      }
    }
    暂停（） {
      这个.标志| = 64;
    }
    恢复（） {
      如果 (this.flags & 64) {
        这个.标志＆=〜64；
        如果 (pausedQueueEffects.has(this)) {
          pausedQueueEffects.删除（这个）；
          这个.触发器（）；
        }
      }
    }
    /**
     * @内部的
     */
    通知（） {
      如果 (this.flags & 2 && !(this.flags & 32)) {
        返回;
      }
      如果（！（this.flags & 8））{
        批次（此）；
      }
    }
    跑步（） {
      如果（！（this.flags & 1））{
        返回this.fn（）；
      }
      这个.标志| = 2;
      清理效果（这个）；
      准备Deps（这个）；
      const prevEffect = activeSub;
      const prevShouldTrack = shouldTrack;
      activeSub =这个；
      应该跟踪 = 真;
      尝试 {
        返回this.fn（）；
      } 最后 {
        如果 (activeSub !== this) {
          警告$2(
            “活动效果未正确恢复 - 这可能是 Vue 内部错误。”
          （英文）：
        }
        cleanupDeps （这个）；
        活动子元素 = 上一个效果；
        应该轨道 = 上一个应该轨道；
        这个.标志＆=〜2；
      }
    }
    停止（） {
      如果 (this.flags & 1) {
        对于（让链接 = this.deps; 链接; 链接 = link.nextDep）{
          删除子链接；
        }
        这个.deps = 这个.depsTail = void 0;
        清理效果（这个）；
        这个.onStop && 这个.onStop();
        这个.标志＆=〜1；
      }
    }
    扳机（） {
      如果 (this.flags & 64) {
        pausedQueueEffects.添加（这个）；
      } 否则，如果（this.scheduler）{
        这个.调度程序（）；
      } 别的 {
        这个.runIfDirty（）;
      }
    }
    /**
     * @内部的
     */
    运行IfDirty() {
      如果 (isDirty(this)) {
        这个.运行（）；
      }
    }
    弄脏（）{
      返回 isDirty(this);
    }
  }
  让 batchDepth = 0;
  让 batchedSub；
  让 batchedComputed；
  函数批处理（sub，isComputed = false）{
    子标志 |= 8;
    如果（已计算）{
      子.下一个=batchedComputed;
      批量计算 = 子;
      返回;
    }
    子类.下一个=batchedSub；
    分批处理=子；
  }
  函数启动Batch() {
    批量深度++；
  }
  函数endBatch（）{
    如果（--batchDepth> 0）{
      返回;
    }
    如果（批量计算）{
      让 e = batchedComputed;
      批量计算 = 无效 0;
      当（e）{
        const 下一个 = e.下一个;
        e.next = void 0;
        e.标志 &= ~8;
        e=下一个；
      }
    }
    让错误；
    虽然（batchedSub）{
      让 e = batchedSub;
      批量处理子类 = 无效 0;
      当（e）{
        const 下一个 = e.下一个;
        e.next = void 0;
        e.标志 &= ~8;
        如果 (e.flags & 1) {
          尝试 {
            ；
            e.触发器（）；
          } 捕获 (错误) {
            如果（！错误）错误=错误；
          }
        }
        e=下一个；
      }
    }
    如果（错误）抛出错误；
  }
  函数 prepareDeps(sub) {
    对于（让链接 = sub.deps; 链接; 链接 = link.nextDep）{
      链接.版本 = -1;
      链接.prevActiveLink = 链接.dep.activeLink;
      链接.dep.activeLink = 链接;
    }
  }
  函数 cleanupDeps(sub) {
    讓頭部；
    让 tail = sub.depsTail;
    让链接=尾部；
    while (链接) {
      const prev = link.prevDep;
      如果（链接.版本=== -1）{
        如果（link === tail）tail = prev;
        删除子链接；
        删除依赖（链接）；
      } 别的 {
        头=链接；
      }
      链接.dep.activeLink = 链接.prevActiveLink;
      链接.prevActiveLink = void 0;
      链接 = 上一个；
    }
    子.deps = 头部;
    sub.depsTail = 尾部；
  }
  函数 isDirty（子）{
    对于（让链接 = sub.deps; 链接; 链接 = link.nextDep）{
      如果 (link.dep.version !== link.version || link.dep.computed && (refreshComputed(link.dep.computed) || link.dep.version !== link.version)) {
        返回 true；
      }
    }
    如果（子_dirty）{
      返回 true；
    }
    返回 false；
  }
  函数刷新计算（计算）{
    如果 (computed.flags & 4 && !(computed.flags & 16)) {
      返回;
    }
    计算.标志 &= ~16;
    如果 (computed.globalVersion === globalVersion) {
      返回;
    }
    计算.全局版本 = 全局版本;
    const dep = 计算.dep;
    计算.标志 |= 2;
    如果 (dep.version > 0 && !computed.isSSR && computed.deps && !isDirty (computed)) {
      计算.标志 &= ~2;
      返回;
    }
    const prevSub = activeSub;
    const prevShouldTrack = shouldTrack;
    activeSub = 计算；
    应该跟踪 = 真;
    尝试 {
      准备Deps（计算）；
      const 值 = 计算.fn(计算._值);
      如果 (dep.version === 0 || hasChanged(value, computed._value)) {
        计算._value = 值;
        依赖版本++；
      }
    } 捕获 (错误) {
      依赖版本++；
      抛出错误；
    } 最后 {
      活动子项 = 上一个子项;
      应该轨道 = 上一个应该轨道；
      cleanupDeps（计算）；
      计算.标志 &= ~2;
    }
  }
  函数 removeSub (link, soft = false) {
    const { dep， prevSub， nextSub } = link;
    如果（prevSub）{
      上一个子项.下一个子项 = 下一个子项;
      链接.prevSub = void 0;
    }
    如果（下一个子项）{
      下一个子项.上一个子项 = 上一个子项;
      链接.nextSub = void 0;
    }
    如果 (dep.subsHead === 链接) {
      dep.subsHead = nextSub;
    }
    如果 (dep.subs === 链接) {
      dep.subs = prevSub;
      如果 (!prevSub && dep.computed) {
        dep.计算.标志 &= ~4;
        for (let l = dep.compulated.deps; l; l = l.nextDep) {
          移除子节点（l， true）；
        }
      }
    }
    如果 (!soft && !--dep.sc && dep.map) {
      dep.map.删除（dep.key）；
    }
  }
  函数 removeDep (链接) {
    const { prevDep, nextDep } = 链接;
    如果（上一个分支）{
      上一个Dep.下一个Dep = 下一个Dep;
      链接.prevDep = void 0;
    }
    如果（下一个部门）{
      下一个Dep.上一个Dep = 上一个Dep;
      链接.nextDep = void 0;
    }
  }
  函数效果（fn，选项）{
    如果（fn.effect 实例为 ReactiveEffect）{
      fn = fn.效果.fn;
    }
    const e = 新的 ReactiveEffect (fn);
    如果（选项）{
      扩展（e，选项）；
    }
    尝试 {
      运行（）；
    } 捕获 (错误) {
      停止（）；
      抛出错误；
    }
    const runner = e.run.bind(e);
    跑步者.效果 = e;
    回跑者；
  }
  函数停止（跑步者）{
    跑步者.效果.停止（）；
  }
  让 shouldTrack = true;
  const trackStack = [];
  函数暂停跟踪() {
    trackStack.push（应该跟踪）；
    应该跟踪 = false;
  }
  函数resetTracking（）{
    const last = trackStack.pop();
    shouldTrack = last === void 0 ? true : last;
  }
  函数 cleanupEffect(e) {
    const { 清理 } = e;
    e.清理 = void 0;
    如果（清理）{
      const prevSub = activeSub;
      活动子类 = 无效 0;
      尝试 {
        清理（​​）;
      } 最后 {
        活动子项 = 上一个子项;
      }
    }
  }

  让全局版本 = 0；
  类链接{
    构造函数（sub，dep）{
      这个.sub = sub;
      这个.dep = dep;
      这个.版本 = 依赖.版本;
      这个.nextDep = 这个.prevDep = 这个.nextSub = 这个.prevSub = 这个.prevActiveLink = void 0;
    }
  }
  类 Dep {
    构造函数（计算）{
      这个.计算=计算;
      这个.版本=0；
      /**
       * 此依赖与当前活动效果之间的链接
       */
      这个.activeLink = void 0;
      /**
       * 表示订阅效果的双向链表（尾部）
       */
      这个.subs = void 0;
      /**
       * 用于对象属性依赖清理
       */
      这个.地图= void 0;
      这个.key = void 0;
      /**
       * 订阅者计数器
       */
      这个.sc = 0;
      {
        这个.subsHead = void 0;
      }
    }
    跟踪（调试信息）{
      如果 (!activeSub || !shouldTrack || activeSub === this.computed) {
        返回;
      }
      让链接 = 这个.activeLink;
      如果 (link === void 0 || link.sub !== activeSub) {
        链接 = this.activeLink = 新的 Link(activeSub，this);
        如果 (!activeSub.deps) {
          activeSub.deps = activeSub.depsTail = 链接;
        } 别的 {
          链接.prevDep = activeSub.depsTail;
          activeSub.depsTail.nextDep = 链接；
          activeSub.depsTail = 链接；
        }
        添加子链接；
      } 否则，如果 (link.version === -1) {
        链接.版本 = 这个.版本;
        如果（link.nextDep）{
          const next = link.nextDep;
          下一个.上一个Dep = 链接.上一个Dep;
          如果（link.prevDep）{
            链接.prevDep.nextDep = 下一个;
          }
          链接.prevDep = activeSub.depsTail;
          链接.nextDep = void 0;
          activeSub.depsTail.nextDep = 链接；
          activeSub.depsTail = 链接；
          如果（activeSub.deps === 链接）{
            activeSub.deps = 下一步；
          }
        }
      }
      如果（activeSub.onTrack）{
        activeSub.onTrack（
          延长（
            {
              效果：activeSub
            }，
            调试信息
          ）
        （英文）：
      }
      返回链接；
    }
    触发器（调试信息）{
      这个.版本++；
      全局版本++；
      这个.通知（调试信息）；
    }
    通知（调试信息）{
      开始批次（）；
      尝试 {
        如果 (真) {
          对于（让 head = this.subsHead; head; head = head.nextSub）{
            如果 (head.sub.onTrigger && !(head.sub.flags & 8)) {
              head.sub.onTrigger（
                延长（
                  {
                    效果：head.sub
                  }，
                  调试信息
                ）
              （英文）：
            }
          }
        }
        对于（让链接 = this.subs; 链接; 链接 = link.prevSub）{
          如果（link.sub.通知（））{
            ；
            链接.sub.dep.通知()；
          }
        }
      } 最后 {
        结束批次（）；
      }
    }
  }
  函数 addSub (链接) {
    链接.dep.sc++；
    如果 (link.sub.flags & 4) {
      const 计算 = 链接.dep.计算;
      如果（计算 && ！link.dep.subs）{
        计算.标志 |= 4 | 16;
        for (let l = Computed.deps; l; l = l.nextDep) {
          添加Sub（l）；
        }
      }
      const currentTail = link.dep.subs;
      如果 (currentTail !== 链接) {
        链接.prevSub = currentTail;
        如果 (currentTail) currentTail.nextSub = link;
      }
      如果 (link.dep.subsHead === void 0) {
        链接.dep.subsHead = 链接;
      }
      链接.dep.subs = 链接;
    }
  }
  const targetMap = /* @__PURE__ */ new WeakMap();
  const ITERATE_KEY = 符号（
    “对象迭代”
  （英文）：
  const MAP_KEY_ITERATE_KEY = 符号（
    “地图键迭代”
  （英文）：
  const ARRAY_ITERATE_KEY = 符号（
    “数组迭代”
  （英文）：
  函数跟踪（目标，类型，键）{
    如果 (shouldTrack && activeSub) {
      让 depsMap = targetMap.get(target);
      如果 (!depsMap) {
        targetMap.设置（target，depsMap = /* @__PURE__ */ new Map()）；
      }
      让 dep = depsMap.get(key);
      如果（！dep）{
        depsMap.设置（key，dep = new Dep（））;
        dep.地图 = depsMap;
        dep.key = 键；
      }
      {
        出发地.track({
          目标，
          类型，
          钥匙
        });
      }
    }
  }
  函数触发器（目标，类型，键，新值，旧值，旧目标）{
    const depsMap = targetMap.get(目标);
    如果 (!depsMap) {
      全局版本++；
      返回;
    }
    const 运行 = (dep) => {
      如果 (依赖) {
        {
          dep.触发器（{
            目标，
            类型，
            钥匙，
            新值，
            旧值，
            旧目标
          });
        }
      }
    };
    开始批次（）；
    如果（类型===“clear”）{
      depsMap.forEach(运行);
    } 别的 {
      复制代码
      const isArrayIndex = targetIsArray && isIntegerKey(key);
      如果 (targetIsArray && 键 === “长度”) {
        const newLength = Number(newValue);
        depsMap.forEach((dep, key2) => {
          如果 (key2 === "length" || key2 === ARRAY_ITERATE_KEY || !isSymbol(key2) && key2 >= newLength) {
            运行（dep）；
          }
        });
      } 别的 {
        如果 (key !== void 0 || depsMap.has(void 0)) {
          运行（depsMap.get（key））；
        }
        如果（isArrayIndex）{
          运行（depsMap.get（ARRAY_ITERATE_KEY））；
        }
        开关（类型）{
          案例“添加”：
            如果 (!targetIsArray) {
              运行（depsMap.get（ITERATE_KEY））；
              如果（isMap（目标））{
                运行（depsMap.get（MAP_KEY_ITERATE_KEY））；
              }
            } 否则，如果 (isArrayIndex) {
              运行（depsMap.get（"长度"））；
            }
            休息;
          案例“删除”：
            如果 (!targetIsArray) {
              运行（depsMap.get（ITERATE_KEY））；
              如果（isMap（目标））{
                运行（depsMap.get（MAP_KEY_ITERATE_KEY））；
              }
            }
            休息;
          案例“设置”：
            如果（isMap（目标））{
              运行（depsMap.get（ITERATE_KEY））；
            }
            休息;
        }
      }
    }
    结束批次（）；
  }
  函数 getDepFromReactive (对象，键) {
    const depMap = targetMap.get(对象);
    返回 depMap && depMap.get(key);
  }

  函数reactiveReadArray（数组）{
    const raw = toRaw(数组);
    如果（raw === array）返回 raw；
    轨道（原始，“迭代”，ARRAY_ITERATE_KEY）；
    返回 isShallow(array) ? raw : raw.map(toReactive);
  }
  函数 shallowReadArray(arr) {
    跟踪（arr = toRaw（arr），“迭代”，ARRAY_ITERATE_KEY）；
    返回 arr；
  }
  const 数组仪器 = {
    __proto__: 空，
    [符号.迭代器]() {
      返回迭代器（this，Symbol.iterator，toReactive）；
    }，
    连接（...参数）{
      返回 reactReadArray(this).concat(
        ...args.map((x) => isArray(x) ? reactReadArray(x) : x)
      （英文）：
    }，
    条目（）{
      返回迭代器（this，“entries”，（值）=> {
        值[1] = toReactive(值[1]);
        返回值；
      });
    }，
    每个（fn，thisArg）{
      返回 apply(this, "every", fn, thisArg, void 0, 参数);
    }，
    过滤器（fn，thisArg）{
      返回应用（this，“filter”，fn，thisArg，（v）=> v.map（toReactive），参数）；
    }，
    查找（fn，thisArg）{
      返回应用（this，“find”，fn，thisArg，toReactive，参数）；
    }，
    findIndex（fn，thisArg）{
      返回 apply(this, "findIndex", fn, thisArg, void 0, 参数);
    }，
    findLast(fn，thisArg) {
      返回应用（this，“findLast”，fn，thisArg，toReactive，参数）；
    }，
    findLastIndex（fn，thisArg）{
      返回 apply(this, "findLastIndex", fn, thisArg, void 0, 参数);
    }，
    // flat、flatMap 可以从 ARRAY_ITERATE 中获益，但实现起来并不简单
    forEach(fn，thisArg) {
      返回 apply(this, "forEach", fn, thisArg, void 0, 参数);
    }，
    包括（...参数）{
      返回 searchProxy（this，“includes”，args）；
    }，
    索引（...参数）{
      返回 searchProxy（this，“indexOf”，args）；
    }，
    连接（分隔符）{
      返回 reactReadArray(this).join(separator);
    }，
    // keys() 迭代器仅读取“长度”，无需优化
    lastIndexOf（...参数）{
      返回 searchProxy（this，“lastIndexOf”，args）；
    }，
    映射（fn，thisArg）{
      返回 apply(this, "map", fn, thisArg, void 0, 参数);
    }，
    流行音乐（） {
      返回noTracking（this，“pop”）；
    }，
    推送（...参数）{
      返回 noTracking(this, "push", args);
    }，
    减少（fn，...args）{
      返回 reduce(this, "reduce", fn, args);
    }，
    reduceRight（fn，...args）{
      返回 reduce(this, "reduceRight", fn, args);
    }，
    转移（） {
      返回noTracking（this，“shift”）；
    }，
    // 切片可以使用 ARRAY_ITERATE 但似乎也需要范围跟踪
    一些（fn，thisArg）{
      返回 apply(this, "some", fn, thisArg, void 0,arguments);
    }，
    拼接（...参数）{
      返回noTracking（this，“splice”，args）；
    }，
    反转() {
      返回 reactReadArray(this).toReversed();
    }，
    toSorted（比较器）{
      返回 reactReadArray(this).toSorted(comparer);
    }，
    到Spliced（...参数）{
      返回 reactReadArray(this).toSpliced(...args);
    }，
    取消移位（...参数）{
      返回 noTracking(this, "unshift", args);
    }，
    值() {
      返回迭代器（this，“values”，toReactive）；
    }
  };
  函数迭代器（自身，方法，wrapValue）{
    const arr = shallowReadArray(self);
    const iter = arr[方法]();
    如果 (arr !== self && !isShallow(self)) {
      iter._next = iter.next;
      iter.next = () => {
        const 结果 = iter._next();
        如果（结果.值）{
          结果.值 = wrapValue(结果.值);
        }
        返回结果；
      };
    }
    返回 iter；
  }
  const arrayProto = Array.prototype;
  函数 apply(self，方法，fn，thisArg，wrappedRetFn，args) {
    const arr = shallowReadArray(self);
    const needsWrap = arr !== self && !isShallow(self);
    const methodFn = arr[方法];
    如果 (methodFn !== arrayProto[method]) {
      const result2 = methodFn.apply(self, args);
      返回 needsWrap ? toReactive(result2) : result2;
    }
    让 wrappedFn = fn;
    如果（arr！==自身）{
      如果（需要换行）{
        wrappedFn = 函数（项目，索引）{
          返回 fn.call(this, toReactive(item), index, self);
        };
      } 否则，如果 (fn.length > 2) {
        wrappedFn = 函数（项目，索引）{
          返回 fn.call(this, item, index, self);
        };
      }
    }
    const result = methodFn.call(arr，wrappedFn，thisArg);
    返回 needsWrap && wrappedRetFn ? wrappedRetFn(result) : result;
  }
  函数reduce（self，方法，fn，args）{
    const arr = shallowReadArray(self);
    让 wrappedFn = fn;
    如果（arr！==自身）{
      如果（！isShallow（self））{
        wrappedFn = 函数（acc，项目，索引）{
          返回 fn.call(this, acc, toReactive(item), index, self);
        };
      } 否则，如果 (fn.length > 3) {
        wrappedFn = 函数（acc，项目，索引）{
          返回 fn.call(this, acc, item, index, self);
        };
      }
    }
    返回 arr[method](wrappedFn，...args);
  }
  函数searchProxy（self，方法，参数）{
    const arr = toRaw（self）;
    跟踪（arr，“迭代”，ARRAY_ITERATE_KEY）；
    const res = arr[方法](...args);
    如果 ((res === -1 || res === false) && isProxy(args[0])) {
      args [0] = toRaw（args [0]）;
      返回 arr[方法](...args);
    }
    返回 res；
  }
  函数noTracking（self，方法，args = []）{
    暂停跟踪（）；
    开始批次（）；
    const res = toRaw(self)[方法].apply(self，args);
    结束批次（）；
    重置跟踪（）；
    返回 res；
  }

  const isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
  constbuiltInSymbols=newSet（
    /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== “参数” && key !== “调用者”).map((key) => Symbol[key]).filter(isSymbol)
  （英文）：
  函数 hasOwnProperty(key) {
    如果（！isSymbol（key））key = String（key）；
    const obj = toRaw(this);
    轨道（obj，“有”，键）；
    返回 obj.hasOwnProperty(key);
  }
  类 BaseReactiveHandler {
    构造函数（_isReadonly = false，_isShallow = false）{
      这个。_isReadonly = _isReadonly;
      这个。_isShallow = _isShallow;
    }
    获取（目标，密钥，接收器）{
      如果（key ===“__v_skip”）返回目标[“__v_skip”]；
      const isReadonly2 = this._isReadonly，isShallow2 = this._isShallow;
      如果 (key === “__v_isReactive”) {
        返回 !isReadonly2;
      } 否则，如果 (key === “__v_isReadonly”) {
        返回isReadonly2；
      } 否则，如果 (key === “__v_isShallow”) {
        返回 isShallow2；
      } 否则，如果 (键 === “__v_raw”) {
        if (receiver === (isReadonly2 ? isShallow2 ? shallowReadonlyMap : readonlyMap : isShallow2 ? shallowReactiveMap : reactMap).get(target) || // 接收器不是反应式代理，但具有相同的原型
        // 这意味着接收者是反应式代理的用户代理
        Object.getPrototypeOf(目标) === Object.getPrototypeOf(接收者)) {
          返回目标；
        }
        返回;
      }
      复制代码
      如果（！isReadonly2）{
        让 fn；
        如果 (targetIsArray && (fn = arrayInstrumentations[key])) {
          返回 fn；
        }
        如果 (key === “hasOwnProperty”) {
          返回 hasOwnProperty；
        }
      }
      const res = Reflect.get(
        目标，
        钥匙，
        // 如果这是一个包装引用的代理，则使用原始引用返回方法
        // 作为接收者，这样我们就不必在 ref 上调用 `toRaw`
        // 它的类方法
        isRef(目标) ? 目标: 接收者
      （英文）：
      如果（isSymbol（key）？builtInSymbols.has（key）：isNonTrackableKeys（key））{
        返回 res；
      }
      如果（！isReadonly2）{
        跟踪（目标，“获取”，键）；
      }
      如果（isShallow2）{
        返回 res；
      }
      如果 (isRef(res)) {
        返回 targetIsArray && isIntegerKey(key) ? res : res.value;
      }
      如果 (isObject(res)) {
        返回 isReadonly2 ? readonly(res) : react(res);
      }
      返回 res；
    }
  }
  类 MutableReactiveHandler 扩展了 BaseReactiveHandler {
    构造函数（isShallow2 = false）{
      超级（false，isShallow2）；
    }
    设置（目标，键，值，接收器）{
      让 oldValue = 目标[key];
      如果 (!this._isShallow) {
        const isOldValueReadonly = isReadonly(旧值);
        如果 (!isShallow(值) && !isReadonly(值)) {
          旧值 = 到原始值 (旧值);
          值 = toRaw(值);
        }
        if (!isArray(目标) && isRef(oldValue) && !isRef(值)) {
          如果（isOldValueReadonly）{
            返回 false；
          } 别的 {
            旧值.值 = 值；
            返回 true；
          }
        }
      }
      const hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
      const 结果 = Reflect.set(
        目标，
        钥匙，
        价值，
        isRef(目标) ? 目标: 接收者
      （英文）：
      如果 (目标 === toRaw(接收器)) {
        如果 (!hadKey) {
          触发器（目标，“添加”，键，值）；
        } 否则，如果 (hasChanged(值，oldValue)) {
          触发器（目标，“设置”，键，值，旧值）；
        }
      }
      返回结果；
    }
    删除属性（目标，键）{
      const hadKey = hasOwn(目标， 键);
      const 旧值 = 目标[key];
      const result = Reflect.deleteProperty(target, key);
      如果 (结果 && hadKey) {
        触发器（目标，“删除”，键，void 0，oldValue）；
      }
      返回结果；
    }
    有（目标，键）{
      const 结果 = Reflect.has(目标，键);
      如果 (!isSymbol(key) || !builtInSymbols.has(key)) {
        跟踪（目标，“有”，键）；
      }
      返回结果；
    }
    ownKeys（目标）{
      追踪（
        目标，
        “迭代”，
        isArray(目标) ? “长度” : ITERATE_KEY
      （英文）：
      返回 Reflect.ownKeys(target);
    }
  }
  类 ReadonlyReactiveHandler 扩展了 BaseReactiveHandler {
    构造函数（isShallow2 = false）{
      超级（true，isShallow2）；
    }
    设置（目标，键）{
      {
        警告$2(
          `对键“${String(key)}”的设置操作失败：目标是只读的。`，
          目标
        （英文）：
      }
      返回 true；
    }
    删除属性（目标，键）{
      {
        警告$2(
          `对键“${String(key)}”的删除操作失败：目标是只读的。`，
          目标
        （英文）：
      }
      返回 true；
    }
  }
  const mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler();
  const readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler();
  const shallowReactiveHandlers = /* @__PURE__ */ new MutableReactiveHandler(true);
  const shallowReadonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler(true);

  const toShallow = (值) => 值;
  const getProto = (v) => Reflect.getPrototypeOf(v);
  函数 createIterableMethod(方法，isReadonly2，isShallow2) {
    返回函数（...参数）{
      const 目标 = 这个["__v_raw"];
      const rawTarget = toRaw(目标);
      const targetIsMap = isMap(rawTarget);
      const isPair = method === “entries” || method === Symbol.iterator && targetIsMap;
      const isKeyOnly = method === "keys" && targetIsMap;
      const innerIterator = 目标[方法](...args);
      const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
      !isReadonly2 && 轨道(
        原始目标，
        “迭代”，
        是否仅针对 Key？MAP_KEY_ITERATE_KEY : ITERATE_KEY
      （英文）：
      返回 {
        // 迭代器协议
        下一个（） {
          const { 值， 完成 } = innerIterator.next();
          返回完成？{值，完成}：{
            值：isPair ？[wrap(value[0])，wrap(value[1])] ：wrap(value)，
            完毕
          };
        }，
        // 可迭代协议
        [符号.迭代器]() {
          返回这个；
        }
      };
    };
  }
  函数 createReadonlyMethod（类型）{
    返回函数（...参数）{
      {
        const key = args[0] ? `在键“${args[0]}”上` : ``;
        警告$2(
          `${capitalize(type)} 操作 ${key} 失败：目标为只读。`,
          toRaw（此）
        （英文）：
      }
      返回类型 === “delete” ? false : 类型 === “clear” ? void 0 : this;
    };
  }
  函数 createInstrumentations（只读，浅）{
    const 仪器 = {
      获取（键）{
        const 目标 = 这个["__v_raw"];
        const rawTarget = toRaw(目标);
        const rawKey = toRaw(key);
        如果（！只读）{
          如果 (hasChanged(key，rawKey)) {
            跟踪（rawTarget，“获取”，键）；
          }
          跟踪（rawTarget，“获取”，rawKey）；
        }
        const { 有 } = getProto(rawTarget);
        const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive;
        如果 (has.call(rawTarget，key)) {
          返回包装（target.get（key））；
        } 否则，如果 (has.call(rawTarget，rawKey)) {
          返回包装（target.get（rawKey））；
        } 否则，如果 (目标 !== rawTarget) {
          目标.获取（键）；
        }
      }，
      获取大小() {
        const 目标 = 这个["__v_raw"];
        ！只读&&跟踪（toRaw（目标），“迭代”，ITERATE_KEY）；
        返回 Reflect.get(target, "size", target);
      }，
      有（键）{
        const 目标 = 这个["__v_raw"];
        const rawTarget = toRaw(目标);
        const rawKey = toRaw(key);
        如果（！只读）{
          如果 (hasChanged(key，rawKey)) {
            跟踪（rawTarget，“有”，键）；
          }
          轨道（rawTarget，“有”，rawKey）；
        }
        返回 key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
      }，
      forEach(回调，thisArg) {
        const 观察到的 = this;
        const 目标 = 观察到的["__v_raw"];
        const rawTarget = toRaw(目标);
        const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive;
        ！只读&&跟踪（rawTarget，“迭代”，ITERATE_KEY）；
        返回目标.forEach((值，键) => {
          返回回调.call（thisArg，wrap（value），wrap（key），观察到的）；
        });
      }
    };
    延长（
      仪器仪表，
      只读？{
        添加：createReadonlyMethod（“添加”），
        设置：createReadonlyMethod（“set”），
        删除：createReadonlyMethod(“删除”)，
        清除：createReadonlyMethod（“清除”）
      } ： {
        添加（值）{
          如果 (!shallow && !isShallow (值) && !isReadonly (值)) {
            值 = toRaw(值);
          }
          const 目标 = toRaw(this);
          const proto = getProto(目标);
          const hadKey = proto.has.call(目标，值);
          如果 (!hadKey) {
            目标.添加（值）；
            触发器（目标，“添加”，值，值）；
          }
          返回这个；
        }，
        设置（键，值）{
          如果 (!shallow && !isShallow (值) && !isReadonly (值)) {
            值 = toRaw(值);
          }
          const 目标 = toRaw(this);
          const { has， get } = getProto(target);
          让 hadKey = has.call(target, key);
          如果 (!hadKey) {
            键 = toRaw (键);
            hadKey = has.call（目标，键）；
          } 别的 {
            checkIdentityKeys（目标，有，密钥）；
          }
          const oldValue = get.call(目标，键);
          目标.设置（键，值）；
          如果 (!hadKey) {
            触发器（目标，“添加”，键，值）；
          } 否则，如果 (hasChanged(值，oldValue)) {
            触发器（目标，“设置”，键，值，旧值）；
          }
          返回这个；
        }，
        删除（键）{
          const 目标 = toRaw(this);
          const { has， get } = getProto(target);
          让 hadKey = has.call(target, key);
          如果 (!hadKey) {
            键 = toRaw (键);
            hadKey = has.call（目标，键）；
          } 别的 {
            checkIdentityKeys（目标，有，密钥）；
          }
          const oldValue = get ? get.call(target, key) : void 0;
          const result = 目标.删除（键）;
          如果（hadKey）{
            触发器（目标，“删除”，键，void 0，oldValue）；
          }
          返回结果；
        }，
        清除（） {
          const 目标 = toRaw(this);
          const hadItems = target.size !== 0;
          const oldTarget = isMap(target) ? new Map(target) : new Set(target) ;
          const 结果 = 目标.清除();
          如果 (hadItems) {
            扳机（
              目标，
              “清除”，
              无效 0，
              无效 0，
              旧目标
            （英文）：
          }
          返回结果；
        }
      }
    （英文）：
    const 迭代器方法 = [
      “钥匙”，
      “价值观”，
      “条目”
      符号.迭代器
    ]；
    iteratorMethods.forEach((方法) => {
      Instrumentations[方法] = createIterableMethod(方法，只读，浅)；
    });
    返回仪器；
  }
  函数 createInstrumentationGetter（isReadonly2，shallow）{
    const Instrumentations = createInstrumentations(isReadonly2，shallow);
    返回 (目标，键，接收者) => {
      如果 (key === “__v_isReactive”) {
        返回 !isReadonly2;
      } 否则，如果 (key === “__v_isReadonly”) {
        返回isReadonly2；
      } 否则，如果 (键 === “__v_raw”) {
        返回目标；
      }
      返回 Reflect.get(
        hasOwn(instrumentations, key) && 目标中是否有键？instrumentations : target,
        钥匙，
        接收者
      （英文）：
    };
  }
  const mutableCollectionHandlers = {
    获取：/*@__PURE__*/createInstrumentationGetter（false，false）
  };
  const shallowCollectionHandlers = {
    获取：/*@__PURE__*/createInstrumentationGetter（false，true）
  };
  const readonlyCollectionHandlers = {
    获取：/*@__PURE__*/createInstrumentationGetter（true，false）
  };
  const shallowReadonlyCollectionHandlers = {
    获取：/*@__PURE__*/createInstrumentationGetter（true，true）
  };
  函数 checkIdentityKeys (目标，有，键) {
    const rawKey = toRaw(key);
    如果 (rawKey !== key && has.call(target, rawKey)) {
      const 类型 = toRawType（目标）；
      警告$2(
        `Reactive ${type} 包含同一对象 ${type === `Map` ? ` as keys` : ``} 的原始版本和反应版本，这可能会导致不一致。避免区分对象的原始版本和反应版本，并且仅使用反应版本（如果可能）。`
      （英文）：
    }
  }

  const reactMap = /* @__PURE__ */ new WeakMap();
  const shallowReactiveMap = /* @__PURE__ */ new WeakMap();
  const readonlyMap = /* @__PURE__ */ new WeakMap();
  const shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
  函数目标类型映射（rawType）{
    开关（原始类型）{
      案例“对象”：
      案例“数组”：
        返回 1/* COMMON */;
      案例“地图”：
      案例“设置”：
      案例“WeakMap”：
      案例“弱集”：
        返回 2 /* 集合 */;
      默认：
        返回 0 /* 无效 */;
    }
  }
  函数获取目标类型（值）{
    返回值["__v_skip"] || !Object.isExtensible(value) ? 0 /* 无效 */ : targetTypeMap(toRawType(value));
  }
  函数反应（目标）{
    如果（isReadonly（目标））{
      返回目标；
    }
    返回 createReactiveObject(
      目标，
      错误的，
      可变处理程序，
      可变集合处理程序，
      反应式地图
    （英文）：
  }
  函数 shallowReactive(目标) {
    返回 createReactiveObject(
      目标，
      错误的，
      shallowReactiveHandlers，
      shallowCollectionHandlers，
      shallowReactiveMap
    （英文）：
  }
  函数只读（目标）{
    返回 createReactiveObject(
      目标，
      真的，
      readonlyHandler，
      readonlyCollectionHandlers，
      只读地图
    （英文）：
  }
  函数 shallowReadonly (目标) {
    返回 createReactiveObject(
      目标，
      真的，
      shallowReadonlyHandlers，
      shallowReadonlyCollectionHandlers，
      shallowReadonlyMap
    （英文）：
  }
  函数 createReactiveObject(target，isReadonly2，baseHandlers，collectionHandlers，proxyMap) {
    如果 (!isObject(目标)) {
      {
        警告$2(
          `值无法设为 ${isReadonly2 ? "readonly" : "reactive"}: ${String(
          目标
        ）}`
        （英文）：
      }
      返回目标；
    }
    如果（目标["__v_raw"] && ！（isReadonly2 && 目标["__v_isReactive"]））{
      返回目标；
    }
    const externalProxy = proxyMap.get(target);
    如果（现有代理）{
      返回现有的代理；
    }
    const 目标类型 = 获取目标类型（目标）；
    如果 (targetType === 0 /* 无效 */) {
      返回目标；
    }
    const 代理 = 新代理（
      目标，
      targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers
    （英文）：
    proxyMap.设置（目标，代理）；
    返回代理；
  }
  函数 isReactive (值) {
    如果（isReadonly（值））{
      返回 isReactive（值[“__v_raw”]）；
    }
    返回！（值&&值[“__v_isReactive”]）；
  }
  函数 isReadonly（值）{
    返回！（值&&值[“__v_isReadonly”]）；
  }
  函数 isShallow (值) {
    返回！（值&&值[“__v_isShallow”]）；
  }
  函数 isProxy（值）{
    返回值？!!value["__v_raw"] : false;
  }
  函数 toRaw(观察) {
    const raw = 观察到的 && 观察到的["__v_raw"];
    返回 raw ？ toRaw（raw）：观察到的；
  }
  函数 markRaw(值) {
    如果 (!hasOwn(value, "__v_skip") && Object.isExtensible(value)) {
      def（值，“__v_skip”，true）；
    }
    返回值；
  }
  const toReactive = (value) => isObject(value) ?reactive(value) : value;
  const toReadonly = (value) => isObject(value) ? readonly(value) : value;

  函数 isRef(r) {
    返回 r ? r["__v_isRef"] === true : false;
  }
  函数 ref(值) {
    返回 createRef（值，false）；
  }
  函数 shallowRef (值) {
    返回 createRef(value, true);
  }
  函数 createRef（rawValue，shallow）{
    如果 (isRef(rawValue)) {
      返回原始值；
    }
    返回新的 RefImpl(rawValue, shallow);
  }
  类 RefImpl {
    构造函数（值，isShallow2）{
      这个.dep = 新的Dep（）;
      这[“__v_isRef”] = true;
      这[“__v_isShallow”] = false;
      this._rawValue = isShallow2 ?值：toRaw(值);
      this._value = isShallow2 ? value : toReactive(value);
      这[“__v_isShallow”] = isShallow2；
    }
    获取值() {
      {
        此.dep.track({
          目标：这个，
          输入：“获取”，
          键：“值”
        });
      }
      返回这个._value；
    }
    设置值（新值）{
      const 旧值 = this._rawValue;
      const useDirectValue = this["__v_isShallow"] || isShallow(newValue) || isReadonly(newValue);
      newValue = useDirectValue ? newValue : toRaw(newValue);
      如果（hasChanged（新值，旧值））{
        这个._rawValue = 新值;
        复制代码
        {
          这个.dep.触发器（{
            目标：这个，
            类型：“set”，
            键：“值”，
            新值，
            旧值
          });
        }
      }
    }
  }
  函数 triggerRef(ref2) {
    如果（ref2.dep）{
      {
        ref2.dep.触发器({
          目标：ref2，
          类型：“set”，
          键：“值”，
          新值：ref2._value
        });
      }
    }
  }
  函数 unref(ref2) {
    返回 isRef(ref2) ? ref2.value : ref2;
  }
  函数 toValue（源）{
    返回 isFunction(source) ? source() : unref(source);
  }
  const shallowUnwrapHandlers = {
    获取：（目标、键、接收器）=> 键 === “__v_raw” ？目标：unref（Reflect.get（目标、键、接收器）），
    设置：（目标，键，值，接收者）=> {
      const 旧值 = 目标[key];
      如果 (isRef (旧值) && !isRef (值)) {
        旧值.值 = 值；
        返回 true；
      } 别的 {
        返回 Reflect.set(目标，键，值，接收器)；
      }
    }
  };
  函数 proxyRefs (objectWithRefs) {
    返回 isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers);
  }
  类 CustomRefImpl {
    构造函数（工厂）{
      这[“__v_isRef”] = true;
      这个._value = void 0;
      const dep = this.dep = new Dep();
      const { 获取， 设置 } = factory(dep.track.bind(dep), dep.trigger.bind(dep));
      这个._get = 获取;
      这个._set = 设置；
    }
    获取值() {
      返回 this._value = this._get();
    }
    设置值（newVal）{
      这个._set（newVal）；
    }
  }
  函数 customRef(工厂) {
    返回新的 CustomRefImpl（工厂）；
  }
  函数 toRefs (对象) {
    如果 (!isProxy(对象)) {
      warn$2(`toRefs() 期望一个反应对象，但是收到的却是一个普通对象。`);
    }
    const ret = isArray(object) ? new Array(object.length) : {};
    for（对象中的 const 键）{
      ret[key] = propertyToRef(对象，键);
    }
    返回 ret；
  }
  类 ObjectRefImpl {
    构造函数（_object，_key，_defaultValue）{
      这个._object = _object;
      这个._key = _key;
      这个。_默认值=_默认值；
      这[“__v_isRef”] = true;
      这个._value = void 0;
    }
    获取值() {
      const val = this._object[this._key];
      返回 this._value = val === void 0 ?this._defaultValue : val;
    }
    设置值（newVal）{
      这个._object[这个._key] = newVal;
    }
    获取 dep() {
      返回 getDepFromReactive(toRaw(this._object), this._key);
    }
  }
  类 GetterRefImpl {
    构造函数（_getter）{
      这个。_getter = _getter;
      这[“__v_isRef”] = true;
      这个[“__v_isReadonly”] = true;
      这个._value = void 0;
    }
    获取值() {
      返回 this._value = this._getter();
    }
  }
  函数 toRef (源，键，默认值) {
    如果 (isRef(源)) {
      返回源；
    } 否则，如果 (isFunction (源)) {
      返回新的GetterRefImpl（source）；
    } 否则，如果 (isObject(source) && 参数.length > 1) {
      返回 propertyToRef(source, key, defaultValue);
    } 别的 {
      返回 ref(源);
    }
  }
  函数 propertyToRef (源，键，默认值) {
    const val = 源[key];
    返回 isRef(val) ? val : new ObjectRefImpl(source, key, defaultValue);
  }

  类 ComputedRefImpl {
    构造函数（fn，setter，isSSR）{
      这个.fn = fn;
      这个.setter = setter;
      /**
       * @内部的
       */
      这个._value = void 0;
      /**
       * @内部的
       */
      这个.dep = 新的Dep (这个);
      /**
       * @内部的
       */
      这个.__v_isRef = true;
      // TODO 隔离声明“__v_isReadonly”
      // 计算也是跟踪其他依赖项的订阅者
      /**
       * @内部的
       */
      这个.deps = void 0;
      /**
       * @内部的
       */
      这个.depsTail = void 0;
      /**
       * @内部的
       */
      这个.标志=16；
      /**
       * @内部的
       */
      这个.全局版本 = 全局版本 - 1;
      /**
       * @内部的
       */
      这个.下一个= void 0;
      // 为了向后兼容
      这个.效果 = 这个;
      这[“__v_isReadonly”] = ！设置器；
      这个.isSSR = isSSR;
    }
    /**
     * @内部的
     */
    通知（） {
      这个.标志| = 16;
      if (!(this.flags & 8) && // 避免无限自递归
      activeSub !== 这个) {
        批次（此，真）；
        返回 true；
      }
    }
    获取值() {
      const link = this.dep.track({
        目标：这个，
        输入：“获取”，
        键：“值”
      }）；
      刷新计算（这个）；
      如果（链接）{
        链接.版本 = 这个.dep.版本;
      }
      返回这个._value；
    }
    设置值（新值）{
      如果（this.setter）{
        这个.setter（newValue）；
      } 别的 {
        warn$2("写入操作失败：计算值是只读的");
      }
    }
  }
  函数计算$1（getterOrOptions，debugOptions，isSSR = false）{
    让吸气剂；
    让 setter；
    如果（isFunction（getterOrOptions））{
      getter = getter或选项;
    } 别的 {
      获取器 = 获取器或选项.获取;
      设置器 = getterOrOptions.set;
    }
    const cRef = new ComputedRefImpl(getter, setter, isSSR);
    如果（debugOptions && ！isSSR）{
      调试选项
      调试选项
    }
    返回 cRef；
  }

  const TrackOpTypes = {
    "GET": "获取",
    "HAS": "有",
    "ITERATE": "迭代"
  };
  const TriggerOpTypes = {
    “设置”：“设置”，
    "添加"："添加",
    "DELETE": "删除",
    “清除”：“清除”
  };

  const INITIAL_WATCHER_VALUE = {};
  const cleanupMap = /* @__PURE__ */ new WeakMap();
  让 activeWatcher = void 0;
  函数 getCurrentWatcher() {
    返回activeWatcher；
  }
  函数 onWatcherCleanup（cleanupFn，failSilently = false，owner = activeWatcher）{
    如果（所有者）{
      让 cleanups = cleanupMap.get(owner);
      如果（！cleanups）cleanupMap.set（owner，cleanups = []）;
      清理.推送（cleanupFn）；
    } 否则，如果（！failSilently）{
      警告$2(
        当没有活动的观察者可关联时，会调用 onWatcherCleanup()。
      （英文）：
    }
  }
  函数 watch$1(source, cb, options = EMPTY_OBJ) {
    const {immediate, deep, once, scheduler, augmentJob, call } = options;
    const warnInvalidSource = (s) => {
      （选项.onWarn || 警告$2）（
        `无效的观看来源：`，
        年代,
        ``监视源只能是 getter/effect 函数、ref、反应对象或这些类型的数组。''
      （英文）：
    };
    const reactingGetter = (source2) => {
      如果（深）返回源2；
      如果 (isShallow (source2) || deep === false || deep === 0)
        返回遍历（source2，1）；
      返回遍历（source2）；
    };
    让效果；
    让吸气剂；
    让清理；
    让boundCleanup；
    让 forceTrigger = false;
    让 isMultiSource = false;
    如果 (isRef(源)) {
      getter = () => 源.值;
      forceTrigger = isShallow（源）；
    } 否则，如果 (isReactive(source)) {
      getter = () => reactGetter(源);
      forceTrigger = true;
    } 否则，如果 (isArray (源)) {
      是否多源 = true;
      forceTrigger = 源.some((s) => isReactive(s) || isShallow(s));
      getter = () => 源.map((s) => {
        如果 (isRef(s)) {
          返回 s.value；
        } 否则，如果 (isReactive(s)) {
          返回 reactGetter(s);
        } 否则，如果 (isFunction(s)) {
          返回调用？调用（s，2）：s（）；
        } 别的 {
          警告无效来源；
        }
      });
    } 否则，如果 (isFunction (源)) {
      如果（cb）{
        getter = call ? () => call(source, 2) : source;
      } 别的 {
        吸气剂 = () => {
          如果（清理）{
            暂停跟踪（）；
            尝试 {
              清理（​​）;
            } 最后 {
              重置跟踪（）；
            }
          }
          const currentEffect = activeWatcher;
          activeWatcher = 效果；
          尝试 {
            返回调用？调用（源，3，[boundCleanup]）：源（boundCleanup）；
          } 最后{
            活动观察者 = 当前效果；
          }
        };
      }
    } 别的 {
      吸气剂= NOOP；
      警告无效来源（来源）；
    }
    如果（cb && 深）{
      const baseGetter = getter;
      constdepth = deep === true ?Infinity : deep;
      getter = () => 遍历(baseGetter()，深度);
    }
    const 范围 = 获取当前范围 ();
    const watchHandle = () => {
      效果.停止()；
      如果（范围&&范围.active）{
        删除（范围.效果，效果）；
      }
    };
    如果 (once && cb) {
      const _cb = cb;
      cb = (...参数) => {
        _cb（...参数）；
        监视句柄（）；
      };
    }
    让 oldValue = isMultiSource ？新数组（source.length）.填充（INITIAL_WATCHER_VALUE）：INITIAL_WATCHER_VALUE；
    const job = (immediateFirstRun) => {
      如果（！（effect.flags & 1）|| ！effect.dirty && ！immediateFirstRun）{
        返回;
      }
      如果（cb）{
        const newValue = effect.run();
        如果（深|| forceTrigger ||（isMultiSource？newValue.some（（v，i）=> hasChanged（v，oldValue [i]））：hasChanged（newValue，oldValue）））{
          如果（清理）{
            清理（​​）;
          }
          const currentWatcher = activeWatcher;
          activeWatcher = 效果；
          尝试 {
            常量参数 = [
              新值，
              // 第一次更改时，将 undefined 作为旧值传递
              oldValue === INITIAL_WATCHER_VALUE ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE ? [] : oldValue,
              绑定清理
            ]；
            呼叫？呼叫（cb，3，args）：（
              //@ts-期望错误
              cb（...参数）
            （英文）：
            旧值=新值；
          } 最后 {
            活跃观察者 = 当前观察者;
          }
        }
      } 别的 {
        效果.运行()；
      }
    };
    如果（augmentJob）{
      增强工作（工作）；
    }
    效果 = 新的 ReactiveEffect（getter）；
    effect.scheduler = scheduler ? () => scheduler(job, false) : job;
    boundCleanup = （fn）=> onWatcherCleanup（fn，false，效果）；
    清理 = 效果.onStop = () => {
      const cleanups = cleanupMap.get(effect);
      如果（清理）{
        如果（调用）{
          调用（清理，4）；
        } 别的 {
          for (const cleanup2 of cleanups) cleanup2();
        }
        cleanupMap.删除（效果）；
      }
    };
    {
      效果.onTrack = 选项.onTrack;
      效果.onTrigger = 选项.onTrigger;
    }
    如果（cb）{
      如果（立即）{
        工作（真）；
      } 别的 {
        旧值 = 效果.运行();
      }
    } else if（调度程序）{
      调度程序（job.bind（null，true），true）；
    } 别的 {
      效果.运行()；
    }
    watchHandle.暂停 = 效果.暂停.绑定(效果);
    watchHandle.resume = effect.resume.bind(效果);
    手表手柄.停止 = 手表手柄;
    返回监视句柄；
  }
  函数遍历（值，深度 = Infinity，已见）{
    如果（深度<= 0 ||！isObject（值）||值[“__v_skip”]）{
      返回值；
    }
    已看到 = 已看到 || /* @__PURE__ */ new Set();
    如果 (seen.has(value)) {
      返回值；
    }
    已看到.添加（值）；
    深度 - ;
    如果 (isRef (值)) {
      遍历（值.值，深度，已见）；
    } 否则，如果 (isArray (值)) {
      对于（让 i = 0；i < 值.长度；i++）{
        遍历（值[i]，深度，已见）；
      }
    } 否则，如果 (isSet (值) || isMap (值)) {
      值.forEach((v) => {
        遍历（v，深度，可见）；
      });
    } 否则，如果 (isPlainObject(值)) {
      for (const 键输入值) {
        遍历（值[键]，深度，已见）；
      }
      对于（Object.getOwnPropertySymbols（value）的 const 键）{
        如果 (Object.prototype.propertyIsEnumerable.call(值，键)) {
          遍历（值[键]，深度，已见）；
        }
      }
    }
    返回值；
  }

  const 堆栈$1 = [];
  函数pushWarningContext（vnode）{
    堆栈$1.推送（vnode）；
  }
  函数 popWarningContext() {
    堆栈$1.弹出（）；
  }
  让 isWarning = false;
  函数警告$1（msg，...args）{
    如果（isWarning）返回；
    是否警告 = 真；
    暂停跟踪（）；
    const 实例 = 堆栈$1.length ? 堆栈$1[堆栈$1.length - 1].组件 : null;
    const appWarnHandler = 实例 && 实例.appContext.config.warnHandler;
    const trace = getComponentTrace();
    如果（appWarnHandler）{
      调用错误处理（
        appWarnHandler，
        实例，
        11、
        [
          // eslint-禁用下一行无限制语法
          msg + args.map((a) => {
            变量 _a，_b；
            返回 (_b = (_a = a.toString) == null ? void 0 : _a.call(a)) != null ? _b : JSON.stringify(a);
          }）。加入（””），
          实例 && 实例.代理，
          跟踪.地图（
            ({ vnode }) => `位于 <${formatComponentName(instance, vnode.type)}>`
          ).join("\n")，
          痕迹
        ]
      （英文）：
    } 别的 {
      const warnArgs = [`[Vue warn]: ${msg}`, ...args];
      if (trace.length && // 避免在测试期间向控制台发送垃圾邮件
      真的） {
        警告参数.推送（`
`，...formatTrace（跟踪））；
      }
      控制台.warn（...warnArgs）；
    }
    重置跟踪（）；
    是否警告 = false;
  }
  函数 getComponentTrace() {
    让 currentVNode = stack$1[stack$1.length - 1];
    如果 (!currentVNode) {
      返回 [];
    }
    const normalizedStack = [];
    当（currentVNode）{
      const last = normalizedStack[0];
      如果 (last && last.vnode === currentVNode) {
        最后.递归计数++；
      } 别的 {
        normalizedStack.push({
          vnode：当前VNode，
          递归计数：0
        });
      }
      const parentInstance = currentVNode.component && currentVNode.component.parent;
      currentVNode = 父实例 && 父实例.vnode;
    }
    返回 normalizedStack；
  }
  函数格式跟踪（跟踪）{
    const 日志 = [];
    trace.forEach((entry，i) => {
      日志.推（...i === 0 ? [] : [`
`], ...formatTraceEntry(entry));
    });
    返回日志；
  }
  函数 formatTraceEntry({ vnode， recurseCount }) {
    const postfix = recurseCount > 0 ? `... (${recurseCount} 递归调用)` : ``;
    const isRoot = vnode.component ? vnode.component.parent == null : false;
    const open = ` 在 <${formatComponentName(
    vnode.component，
    vnode.类型，
    是Root
  ）}`；
    const 关闭 = `>` + 后缀；
    返回 vnode.props ? [打开，...formatProps(vnode.props)，关闭] : [打开 + 关闭];
  }
  函数 formatProps(props) {
    const res = [];
    const 键 = Object.keys(props);
    键.切片（0，3）。forEach（（键）=> {
      res.push（...formatProp（key，props [key]））;
    });
    如果 (键.长度 > 3) {
      res.推送（`...`）；
    }
    返回 res；
  }
  函数 formatProp（键，值，原始）{
    如果 (isString (值)) {
      值 = JSON.stringify（值）；
      返回原始？值：[`${key}=${value}`]；
    } 否则，如果 (typeof 值 === “number” || typeof 值 === “boolean” || 值 == null) {
      返回原始？值：[`${key}=${value}`]；
    } 否则，如果 (isRef (值)) {
      值 = formatProp(key，toRaw(value.value)，true);
      返回原始？值：[`${key}=Ref<`, value, `>`];
    } 否则，如果 (isFunction (值)) {
      返回 [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
    } 别的 {
      值 = toRaw(值);
      返回原始？值：[`${key}=`，值]；
    }
  }
  函数 assertNumber(val，类型) {
    如果 (val === void 0) {
      返回;
    } 否则，如果 (typeof val !== “number”) {
      warn$1(`${type} 不是有效数字 - 获取到 ${JSON.stringify(val)}。`);
    } 否则，如果 (isNaN(val)) {
      warn$1(`${type} 为 NaN——持续时间表达式可能不正确。`);
    }
  }

  const 错误代码 = {
    “设置功能”：0，
    "0": "设置功能",
    “渲染功能”：1，
    "1": "RENDER_FUNCTION",
    “NATIVE_EVENT_HANDLER”：5，
    "5": "NATIVE_EVENT_HANDLER",
    “组件事件处理程序”：6，
    "6": "组件事件处理程序",
    “VNODE_HOOK”：7，
    "7": "VNODE_HOOK",
    “DIRECTIVE_HOOK”：8，
    "8": "DIRECTIVE_HOOK",
    “TRANSITION_HOOK”：9，
    "9": "TRANSITION_HOOK",
    “APP_ERROR_HANDLER”：10，
    "10": "APP_ERROR_HANDLER",
    “APP_WARN_HANDLER”：11，
    "11": "APP_WARN_HANDLER",
    “功能参考”：12，
    "12": "函数引用",
    “ASYNC_COMPONENT_LOADER”：13，
    "13": "ASYNC_COMPONENT_LOADER",
    “调度程序”：14，
    "14": "调度程序",
    “组件更新”：15，
    "15": "组件更新",
    “APP_UNMOUNT_CLEANUP”：16，
    "16": "APP_UNMOUNT_CLEANUP"
  };
  const 错误类型字符串$1 = {
    ["sp"]: "serverPrefetch 钩子",
    ["bc"]: "beforeCreate 钩子",
    ["c"]: "创建钩子",
    ["bm"]: "beforeMount 钩子",
    ["m"]: "挂载钩",
    ["bu"]: "beforeUpdate 钩子",
    ["u"]: "已更新",
    ["bum"]: "beforeUnmount 钩子",
    [“um”]：“卸载钩子”，
    ["a"]: "激活钩子",
    ["da"]: "已停用钩子",
    ["ec"]: "errorCaptured 钩子",
    [“rtc”]：“renderTracked钩子”，
    ["rtg"]: "renderTriggered钩子",
    [0]: "设置函数",
    [1]：“渲染函数”，
    [2]：“观察者获取者”，
    [3]：“观察者回调”
    [4]：“观察者清理函数”，
    [5]：“本机事件处理程序”，
    [6]：“组件事件处理程序”，
    [7]：“vnode钩子”，
    [8]：“指令钩子”，
    [9]：“过渡钩”，
    [10]: “应用程序错误处理程序”,
    [11]: “应用程序警告处理程序”,
    [12]：“ref函数”，
    [13]：“异步组件加载器”，
    [14]：“调度程序刷新”，
    [15]：“组件更新”，
    [16]：“应用程序卸载清理功能”
  };
  函数 callWithErrorHandling(fn，实例，类型，参数) {
    尝试 {
      返回参数？ fn(...args) : fn();
    } 捕获 (错误) {
      handleError（错误，实例，类型）；
    }
  }
  函数 callWithAsyncErrorHandling(fn，实例，类型，参数) {
    如果 (isFunction(fn)) {
      const res = callWithErrorHandling(fn， 实例， 类型， 参数);
      如果 (res && isPromise(res)) {
        res.catch((err) => {
          handleError（错误，实例，类型）；
        });
      }
      返回 res；
    }
    如果 (isArray (fn)) {
      const 值 = [];
      对于（让 i = 0; i < fn.length; i++）{
        值.push(callWithAsyncErrorHandling(fn[i]，实例，类型，参数));
      }
      返回值；
    } 别的 {
      警告$1(
        `传递给 callWithAsyncErrorHandling() 的值类型无效：${typeof fn}`
      （英文）：
    }
  }
  函数 handleError(err, 实例, 类型, throwInDev = true) {
    const contextVNode = 实例？实例.vnode : null;
    const { 错误处理程序， throwUnhandledErrorInProduction } = 实例 && 实例.appContext.config || EMPTY_OBJ;
    如果（实例）{
      让 cur = 实例.parent;
      const exposedInstance = 实例.代理;
      const 错误信息 = 错误类型字符串$1[类型] ;
      while (当前) {
        const errorCapturedHooks = cur.ec;
        如果 (errorCapturedHooks) {
          对于（让 i = 0；i < errorCapturedHooks.length；i++）{
            如果 (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {
              返回;
            }
          }
        }
        cur = cur.parent;
      }
      如果（错误处理程序）{
        暂停跟踪（）；
        callWithErrorHandling（errorHandler，null，10，[
          犯错，
          暴露实例，
          错误信息
        ]);
        重置跟踪（）；
        返回;
      }
    }
    logError（错误，类型，contextVNode，throwInDev，throwUnhandledErrorInProduction）；
  }
  函数 logError（err，type，contextVNode，throwInDev = true，throwInProd = false）{
    {
      const 信息 = ErrorTypeStrings$1[类型];
      如果（contextVNode）{
        PushWarningContext(contextVNode);
      }
      警告$1（`执行${info}期间出现未处理的错误${info？`：``}`）；
      如果（contextVNode）{
        弹出警告上下文()；
      }
      如果（throwInDev）{
        抛出错误；
      } 别的 {
        控制台.错误（错误）；
      }
    }
  }

  const 队列 = [];
  让 flushIndex = -1；
  const pendingPostFlushCbs = [];
  让 activePostFlushCbs = null;
  让 postFlushIndex = 0;
  const solvedPromise = /* @__PURE__ */ Promise.resolve();
  让 currentFlushPromise = null;
  const RECURSION_LIMIT = 100;
  函数 nextTick (fn) {
    const p = currentFlushPromise || solvedPromise; //查看当前FlushPromise状态
    返回 fn ? p.then(this ? fn.bind(this) : fn) : p;
  }
  函数 findInsertionIndex (id) {
    让开始 = flushIndex + 1；
    让结束 = 队列.长度；
    while (开始 < 结束) {
      const 中间 = 开始 + 结束 >>> 1;
      const middleJob = 队列[中间];
      const middleJobId = getId(middleJob);
      如果 (middleJobId < id || middleJobId === id && middleJob.flags & 2) {
        开始 = 中间 + 1;
      } 别的 {
        结束 = 中间；
      }
    }
    返回开始；
  }
  函数队列作业（作业）{
    如果（！（job.flags & 1））{
      const jobId = getId(工作);
      const lastJob = 队列[queue.length - 1];
      if (!lastJob || // 当作业 ID 大于尾部时，使用快速路径
      !(job.flags & 2) && jobId >= getId(lastJob)) {
        队列.推送（工作）；
      } 别的 {
        队列.splice(findInsertionIndex(jobId), 0, job);
      }
      作业.标志 |= 1;
      队列刷新（）；
    }
  }
  函数queueFlush（）{
    如果 (!currentFlushPromise) {
      currentFlushPromise = solvedPromise.then(刷新作业);
    }
  }
  函数queuePostFlushCb（cb）{
    如果 (!isArray(cb)) {
      如果 (activePostFlushCbs && cb.id === -1) {
        活动PostFlushCbs.splice(postFlushIndex + 1， 0， cb);
      } 否则，如果 (!(cb.flags & 1)) {
        等待PostFlushCbs.推送（cb）；
        cb.标志|= 1;
      }
    } 别的 {
      待处理PostFlushCbs.推（...cb）；
    }
    队列刷新（）；
  }
  函数 flushPreFlushCbs(实例，已看到，i = flushIndex + 1) {
    {
      已看到 = 已看到 || /* @__PURE__ */ new Map();
    }
    对于（；i<队列.长度；i++）{
      const cb = 队列[i];
      如果 (cb && cb.flags & 2) {
        如果 (实例 && cb.id !== 实例.uid) {
          继续;
        }
        如果 (checkRecursiveUpdates(seen，cb)) {
          继续;
        }
        队列.拼接（i，1）；
        我 - ;
        如果 (cb.flags & 4) {
          cb.标志&=~1；
        }
        CB（）；
        如果 (!(cb.flags & 4)) {
          cb.标志&=~1；
        }
      }
    }
  }
  函数 flushPostFlushCbs(seen) {
    如果（pendingPostFlushCbs.length）{
      const deduped = [...new Set(pendingPostFlushCbs)].sort(
        （a，b）=> 获取ID（a）-获取ID（b）
      （英文）：
      等待PostFlushCbs的长度=0；
      如果（activePostFlushCbs）{
        activePostFlushCbs.push（...重复数据删除）；
        返回;
      }
      activePostFlushCbs = 重复数据删除；
      {
        已看到 = 已看到 || /* @__PURE__ */ new Map();
      }
      对于（postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++）{
        const cb = activePostFlushCbs[postFlushIndex];
        如果 (checkRecursiveUpdates(seen，cb)) {
          继续;
        }
        如果 (cb.flags & 4) {
          cb.标志&=~1；
        }
        如果 (!(cb.flags & 8)) cb();
        cb.标志&=~1；
      }
      activePostFlushCbs = 空;
      后刷新索引 = 0;
    }
  }
  const getId = (job) => job.id == null ?job.flags & 2 ? -1 : 无穷大 : job.id;
  函数 flushJobs(seen) {
    {
      已看到 = 已看到 || /* @__PURE__ */ new Map();
    }
    const check = (job) => checkRecursiveUpdates(已看到，job) ;
    尝试 {
      对于（flushIndex = 0; flushIndex < 队列.length; flushIndex++）{
        const 作业 = 队列[flushIndex];
        如果 (工作 && !(job.flags & 8)) {
          如果（检查（工作））{
            继续;
          }
          如果 (job.flags & 4) {
            作业.标志&=~1；
          }
          调用错误处理（
            工作，
            工作.i，
            job.i ？ 15 ： 14
          （英文）：
          如果（！（job.flags & 4））{
            作业.标志&=~1；
          }
        }
      }
    } 最后 {
      对于（；flushIndex < 队列.length；flushIndex++）{
        const 作业 = 队列[flushIndex];
        如果（工作）{
          作业.标志&=~1；
        }
      }
      刷新索引 = -1;
      队列.长度 = 0;
      flushPostFlushCbs（已看到）；
      当前刷新承诺 = 空；
      如果（队列.长度||未决PostFlushCbs.长度）{
        flushJobs（已看到）；
      }
    }
  }
  函数 checkRecursiveUpdates(seen，fn) {
    const count = seen.get(fn) || 0;
    如果 (计数 > RECURSION_LIMIT) {
      const 实例 = fn.i;
      const 组件名称 = 实例 && getComponentName(实例.类型);
      错误处理（
        `组件 <${componentName}> 中的最大递归更新次数已超过 ${componentName ? `：`。这意味着您有一个反应性效果，它正在改变自己的依赖项，从而递归地触发自身。可能的来源包括组件模板、渲染函数、更新的钩子或观察器源函数。`，
        无效的，
        10
      （英文）：
      返回 true；
    }
    已看到.设置（fn，count + 1）；
    返回 false；
  }

  让 isHmrUpdating = false;
  const hmrDirtyComponents = /* @__PURE__ */ new Map();
  {
    获取全局此()。__VUE_HMR_RUNTIME__ = {
      创建记录：tryWrap（创建记录），
      重新渲染：tryWrap（重新渲染），
      重新加载：tryWrap（重新加载）
    };
  }
  const map = /* @__PURE__ */ new Map();
  函数 registerHMR(实例) {
    const id = 实例.类型.__hmrId;
    让记录 = map.get(id);
    如果（！记录）{
      创建记录（id，实例.类型）；
      记录 = 地图.获取（id）;
    }
    记录.实例.添加（实例）；
  }
  函数 unregisterHMR（实例）{
    地图.获取（实例.类型.__hmrId）.实例.删除（实例）；
  }
  函数 createRecord (id，initialDef) {
    如果（map.has（id））{
      返回 false；
    }
    地图.设置（id，{
      initialDef：normalizeClassComponent（initialDef），
      实例：/* @__PURE__ */ new Set()
    });
    返回 true；
  }
  函数 normalizeClassComponent (组件) {
    返回 isClassComponent(component) ? component.__vccOpts : component;
  }
  函数 rerender (id，newRender) {
    const 记录 = map.get(id);
    如果（！记录）{
      返回;
    }
    记录.initialDef.渲染 = newRender;
    [...记录.实例].forEach((实例) => {
      如果（新渲染）{
        实例.渲染 = 新渲染;
        正常化ClassComponent（实例.类型）.render = newRender;
      }
      实例.renderCache = [];
      isHmrUpdating = true;
      实例.更新（）；
      是否正在更新 = false;
    });
  }
  函数重新加载（id，newComp）{
    const 记录 = map.get(id);
    如果（！记录）返回；
    新组件 = 正常化ClassComponent(新组件);
    更新组件定义（record.initialDef，newComp）；
    const 实例 = [...记录.实例];
    对于（让 i = 0; i < 实例.length; i++）{
      const 实例 = 实例[i];
      const oldComp = normalizeClassComponent(实例.类型);
      让 dirtyInstances = hmrDirtyComponents.get(oldComp);
      如果 (!dirtyInstances) {
        如果 (oldComp !== record.initialDef) {
          更新ComponentDef（旧组件，新组件）；
        }
        hmrDirtyComponents.设置（oldComp，dirtyInstances = /* @__PURE__ */ new Set（））;
      }
      dirtyInstances.添加（实例）；
      实例.appContext.propsCache.删除（实例.类型）；
      实例.appContext.emitsCache.删除（实例.类型）；
      实例.appContext.optionsCache.删除（实例.类型）；
      如果（instance.ceReload）{
        dirtyInstances.添加（实例）；
        实例.ceReload（newComp.styles）；
        dirtyInstances.删除（实例）；
      } 否则，如果 (实例.parent) {
        队列作业（（）=> {
          isHmrUpdating = true;
          实例.parent.update()；
          是否正在更新 = false;
          dirtyInstances.删除（实例）；
        });
      } 否则，如果（instance.appContext.reload）{
        实例.appContext.reload（）；
      } 否则，如果 (typeof window !== “undefined”) {
        窗口.位置.重新加载（）；
      } 别的 {
        控制台.警告（
          “[HMR] 根目录或手动安装的实例已修改。需要完全重新加载。”
        （英文）：
      }
      如果 (instance.root.ce && instance !== instance.root) {
        实例.root.ce._removeChildStyle（oldComp）；
      }
    }
    队列PostFlushCb(() => {
      清除（）；
    });
  }
  函数 updateComponentDef(oldComp，newComp) {
    扩展（旧组件，新组件）；
    for (oldComp 中的 const 键) {
      如果 (key !== "__file" && !(newComp 中的 key)) {
        删除oldComp [key]；
      }
    }
  }
  函数 tryWrap（fn）{
    返回 (id, arg) => {
      尝试 {
        返回 fn(id，arg);
      } 捕获（e）{
        控制台.错误(e);
        控制台.警告（
          `[HMR] Vue 组件热重载期间出现问题。需要完全重新加载。`
        （英文）：
      }
    };
  }

  让 devtools$1；
  让缓冲区 = [];
  让 devtoolsNotInstalled = false;
  函数发射$1(事件，...参数) {
    如果（devtools$1）{
      devtools$1.emit(event, ...args);
    } else if (!devtoolsNotInstalled) {
      缓冲区.推送（{ 事件， 参数 }）；
    }
  }
  函数 setDevtoolsHook$1(hook，目标) {
    变量 _a，_b；
    devtools$1 = 钩子;
    如果（devtools$1）{
      devtools$1.enabled = true;
      缓冲区.forEach（（{ 事件， args }）=> devtools $ 1.发出（事件，... args））;
      缓冲区=[]；
    }否则，如果（
      // 处理后期 devtools 注入 - 仅当我们处于实际
      // 浏览器环境避免计时器句柄停滞测试运行器退出
      //（#4815）
      typeof window !== "undefined" && // 一些环境模拟窗口但不完全
      window.HTMLElement && // 也排除 jsdom
      // eslint-禁用下一行无限制语法
      ！（（_b =（_a = window.navigator）==null？void 0：_a.userAgent）==null？void 0：_b.includes（“jsdom”））
    ）{
      const 重播 = 目标.__VUE_DEVTOOLS_HOOK_REPLAY__ = 目标.__VUE_DEVTOOLS_HOOK_REPLAY__ || []；
      重放.推送（（newHook）=> {
        设置DevtoolsHook$1（newHook，目标）；
      });
      设置超时（（）=> {
        如果（！devtools $ 1）{
          目标.__VUE_DEVTOOLS_HOOK_REPLAY__ = null;
          devtoolsNotInstalled = true;
          缓冲区=[]；
        }
      }, 3e3);
    } 别的 {
      devtoolsNotInstalled = true;
      缓冲区=[]；
    }
  }
  函数 devtoolsInitApp(应用程序，版本) {
    发出$1（“app：init”/* APP_INIT */，应用程序，版本，{
      分段，
      文本，
      评论，
      静止的
    });
  }
  函数 devtoolsUnmountApp(应用程序) {
    发出$1（“app：unmount”/*APP_UNMOUNT*/，app）；
  }
  const devtoolsComponentAdded = /* @__PURE__ */ createDevtoolsComponentHook("component:added" /* COMPONENT_ADDED */);
  const devtoolsComponentUpdated = /* @__PURE__ */ createDevtoolsComponentHook("component:updated" /* COMPONENT_UPDATED */);
  const _devtoolsComponentRemoved = /* @__PURE__ */ createDevtoolsComponentHook(
    “组件：已移除”/* COMPONENT_REMOVED */
  （英文）：
  const devtoolsComponentRemoved = (组件) => {
    if (devtools$1 && typeof devtools$1.cleanupBuffer === "function" && // 如果组件未缓冲，则删除该组件
    !devtools$1.cleanupBuffer（组件））{
      _devtoolsComponentRemoved（组件）；
    }
  };
  /*!#__无副作用__*/
  //@__无副作用__
  函数 createDevtoolsComponentHook（hook）{
    返回（组件）=> {
      发射$1(
        钩，
        组件.appContext.app，
        组件.uid，
        组件.parent ? 组件.parent.uid : void 0,
        成分
      （英文）：
    };
  }
  const devtoolsPerfStart = /* @__PURE__ */ createDevtoolsPerformanceHook("perf:start" /* PERFORMANCE_START */);
  const devtoolsPerfEnd = /* @__PURE__ */ createDevtoolsPerformanceHook("perf:end" /* PERFORMANCE_END */);
  函数 createDevtoolsPerformanceHook（hook）{
    返回（组件，类型，时间）=> {
      发射$1（钩子，component.appContext.app，component.uid，组件，类型，时间）；
    };
  }
  函数 devtoolsComponentEmit (组件，事件，参数) {
    发射$1(
      “组件：发射”/* COMPONENT_EMIT */，
      组件.appContext.app，
      成分，
      事件，
      参数
    （英文）：
  }

  让 currentRenderingInstance = null;
  让 currentScopeId = null;
  函数 setCurrentRenderingInstance（实例）{
    const prev = currentRenderingInstance;
    当前渲染实例 = 实例；
    currentScopeId = 实例 && 实例.type.__scopeId || 空;
    返回上一个；
  }
  函数 pushScopeId (id) {
    当前作用域ID = id;
  }
  函数 popScopeId() {
    当前作用域ID = 空；
  }
  const withScopeId = (_id) => withCtx;
  函数 withCtx(fn，ctx = currentRenderingInstance，isNonScopedSlot) {
    如果（！ctx）返回fn；
    如果（fn._n）{
      返回 fn；
    }
    const renderFnWithContext = (...args) => {
      如果（renderFnWithContext._d）{
        设置BlockTracking（-1）；
      }
      const prevInstance = setCurrentRenderingInstance(ctx);
      让 res；
      尝试 {
        res = fn（...参数）；
      } 最后 {
        设置当前渲染实例（上一个实例）；
        如果（renderFnWithContext._d）{
          设置BlockTracking（1）；
        }
      }
      {
        devtoolsComponentUpdated（ctx）；
      }
      返回 res；
    };
    renderFnWithContext._n = true;
    renderFnWithContext._c = true;
    renderFnWithContext._d = true;
    返回 renderFnWithContext;
  }

  函数validateDirectiveName（名称）{
    如果（isBuiltInDirective（名称））{
      warn$1("不要使用内置指令id作为自定义指令id：" + name);
    }
  }
  函数 withDirectives（vnode，指令）{
    如果 (currentRenderingInstance === null) {
      warn$1(`withDirectives 只能在渲染函数内部使用。`);
      返回vnode；
    }
    const 实例 = getComponentPublicInstance(currentRenderingInstance);
    const 绑定 = vnode.dirs || (vnode.dirs = []);
    对于（让 i = 0; i < 指令.length; i++）{
      让 [dir, value, arg, modifiers = EMPTY_OBJ] = directives[i];
      如果（目录）{
        如果（isFunction（dir））{
          目录 = {
            安装：目录，
            更新：目录
          };
        }
        如果（dir.deep）{
          遍历（值）；
        }
        绑定.推（{
          目录，
          实例，
          价值，
          旧值：void 0，
          arg，
          修饰符
        });
      }
    }
    返回vnode；
  }
  函数invokeDirectiveHook（vnode，prevVNode，实例，名称）{
    const 绑定 = vnode.dirs;
    const oldBindings = prevVNode && prevVNode.dirs;
    对于（让 i = 0; i < bindings.length; i++）{
      const 绑定 = 绑定[i];
      如果（旧绑定）{
        绑定.oldValue = oldBindings[i].值;
      }
      让 hook = binding.dir[name];
      如果（钩子）{
        暂停跟踪（）；
        callWithAsyncErrorHandling（钩子，实例，8，[
          vnode.el，
          绑定，
          虚拟节点，
          上一个VNode
        ]);
        重置跟踪（）；
      }
    }
  }

  const TeleportEndKey = Symbol("_vte");
  const isTeleport = (类型) => 类型.__isTeleport;
  const isTeleportDisabled = (props) => props && (props.disabled || props.disabled === "");
  const isTeleportDeferred = (props) => props && (props.defer || props.defer === "");
  const isTargetSVG = (target) => typeof SVGElement !== “undefined” && target instanceof SVGElement;
  const isTargetMathML = (target) => typeof MathMLElement === “function” && target instanceof MathMLElement;
  const resolveTarget = (props, select) => {
    const targetSelector = props && props.to;
    如果 (isString(targetSelector)) {
      如果（！选择）{
        警告$1(
          `当前渲染器不支持 Teleports 的字符串目标。（缺少 querySelector 渲染器选项）`
        （英文）：
        返回空值；
      } 别的 {
        const 目标 = 选择 (目标选择器);
        如果（！目标&&！isTeleportDisabled（props））{
          警告$1(
            `无法使用选择器“${targetSelector}”定位 Teleport 目标。请注意，目标元素必须在安装组件之前存在 - 即目标不能由组件本身呈现，理想情况下应该位于整个 Vue 组件树之外。`
          （英文）：
        }
        返回目标；
      }
    } 别的 {
      如果（！targetSelector && ！isTeleportDisabled（props））{
        warn$1(`无效的传送目标：${targetSelector}`);
      }
      返回目标选择器；
    }
  };
  const TeleportImpl = {
    名称：“传送”，
    __isTeleport： true，
    进程（n1，n2，容器，锚点，parentComponent，parentSuspense，命名空间，slotScopeIds，优化，内部）{
      常量 {
        mc：挂载子项，
        pc：patchChildren，
        pbc: patchBlockChildren，
        o：{ 插入，查询选择器，创建文本，创建评论 }
      } = 内部；
      const disabled = isTeleportDisabled（n2.props）；
      让 { shapeFlag， children， dynamicChildren } = n2；
      如果（isHmrUpdating）{
        优化=错误；
        动态儿童=空；
      }
      如果 (n1 == 空) {
        const placeholder = n2.el = createComment("传送开始") ;
        const mainAnchor = n2.anchor = createComment("传送结束") ;
        插入（占位符，容器，锚点）；
        插入（mainAnchor，容器，锚点）；
        const mount = (容器2，锚点2) => {
          如果 (shapeFlag & 16) {
            如果 (parentComponent && parentComponent.isCE) {
              父组件.ce._teleportTarget = 容器2;
            }
            mountChildren（
              孩子们，
              容器2，
              锚点2，
              父组件，
              父级悬念，
              命名空间，
              slotScopeIds，
              优化
            （英文）：
          }
        };
        const mountToTarget = () => {
          const 目标 = n2.目标 = resolveTarget(n2.props， querySelector);
          const targetAnchor = prepareAnchor(目标， n2， createText， 插入);
          如果（目标）{
            如果（命名空间！==“svg”&&isTargetSVG（目标））{
              命名空间 = “svg”;
            } 否则，如果（命名空间！==“mathml”&& isTargetMathML（目标））{
              命名空间 = “mathml”;
            }
            如果（！已禁用）{
              安装（目标，目标锚）；
              更新CssVars（n2，false）；
            }
          } 否则，如果（！禁用）{
            警告$1(
              “装载时的传送目标无效：”，
              目标，
              `（${typeof target}）`
            （英文）：
          }
        };
        如果（已禁用）{
          安装（容器，mainAnchor）；
          更新CssVars（n2，true）；
        }
        如果（isTeleportDeferred（n2.props））{
          队列后渲染效果（）=> {
            安装到目标（）；
            n2.el.__isMounted = true;
          }，父Suspense);
        } 别的 {
          安装到目标（）；
        }
      } 别的 {
        如果（isTeleportDeferred（n2.props）&&！n1.el.__isMounted）{
          队列后渲染效果（）=> {
            TeleportImpl.进程（
              n1，
              n2，
              容器，
              锚，
              父组件，
              父级悬念，
              命名空间，
              slotScopeIds，
              优化，
              内部
            （英文）：
            删除 n1.el.__isMounted；
          }，父Suspense);
          返回;
        }
        n2.el = n1.el;
        n2.目标开始 = n1.目标开始;
        const mainAnchor = n2.anchor = n1.anchor;
        const 目标 = n2.目标 = n1.目标;
        const 目标锚点 = n2.目标锚点 = n1.目标锚点;
        const wasDisabled = isTeleportDisabled(n1.props);
        const currentContainer = wasDisabled ? 容器 : 目标;
        复制代码
        如果（命名空间===“svg”|| isTargetSVG（目标））{
          命名空间 = “svg”;
        } 否则，如果（命名空间 === “mathml” || isTargetMathML（目标））{
          命名空间 = “mathml”;
        }
        如果（动态儿童）{
          patchBlockChildren（
            n1.动态儿童，
            dynamicChildren，
            当前容器，
            父组件，
            父级悬念，
            命名空间，
            slotScopeIds
          （英文）：
          遍历静态子代（n1，n2，true）；
        } 否则，如果（！优化）{
          patchChildren（
            n1，
            n2，
            当前容器，
            当前锚点，
            父组件，
            父级悬念，
            命名空间，
            slotScopeIds，
            错误的
          （英文）：
        }
        如果（已禁用）{
          如果（！wasDisabled）{
            移动传送（
              n2，
              容器，
              主锚，
              内部，
              1
            （英文）：
          } 别的 {
            如果 (n2.props && n1.props && n2.props.to !== n1.props.to) {
              n2.道具.to = n1.道具.to;
            }
          }
        } 别的 {
          如果 ((n2.props && n2.props.to) !== (n1.props && n1.props.to)) {
            const nextTarget = n2.target = resolveTarget(
              n2.道具，
              查询选择器
            （英文）：
            如果（下一个目标）{
              移动传送（
                n2，
                下一个目标，
                无效的，
                内部，
                0
              （英文）：
            } 别的 {
              警告$1(
                “更新时传送目标无效：”，
                目标，
                `（${typeof target}）`
              （英文）：
            }
          } 否则，如果（wasDisabled）{
            移动传送（
              n2，
              目标，
              目标锚点，
              内部，
              1
            （英文）：
          }
        }
        更新CssVars（n2，已禁用）；
      }
    }，
    删除（vnode，parentComponent，parentSuspense，{ um：卸载，o：{ 删除：hostRemove }}，doRemove）{
      常量 {
        形状标志，
        孩子们，
        锚，
        目标开始，
        目标锚点，
        目标，
        道具
      } = 虚拟节点；
      如果（目标）{
        主机删除（目标开始）；
        主机删除（目标锚点）；
      }
      执行删除 && 主机删除 (锚点)；
      如果 (shapeFlag & 16) {
        const shouldRemove = doRemove || ！isTeleportDisabled（props）；
        对于（让 i = 0; i < children.length; i++）{
          const 孩子 = 孩子[i];
          卸载（
            孩子，
            父组件，
            父级悬念，
            应该删除，
            !!child.dynamicChildren
          （英文）：
        }
      }
    }，
    移动：moveTeleport，
    水合物：水合物传送
  };
  函数 moveTeleport(vnode，容器，parentAnchor，{ o：{ 插入 }，m：移动 }，moveType = 2) {
    如果 (moveType === 0) {
      插入（vnode.targetAnchor，容器，parentAnchor）；
    }
    const { el，anchor，shapeFlag，children，props } = vnode;
    const isReorder = moveType === 2;
    如果（是重新排序）{
      插入（el，容器，parentAnchor）；
    }
    如果（！isReorder || isTeleportDisabled（props））{
      如果 (shapeFlag & 16) {
        对于（让 i = 0; i < children.length; i++）{
          移动（
            孩子[i]，
            容器，
            父锚点，
            2
          （英文）：
        }
      }
    }
    如果（是重新排序）{
      插入（锚点，容器，父锚点）；
    }
  }
  函数 hydrateTeleport(node, vnode, parentComponent, parentSuspense, slotScopeIds, 优化, {
    o：{ nextSibling，parentNode，querySelector，插入，createText }
  }, 水合儿童) {
    const target = vnode.target = resolveTarget（
      vnode.props，
      查询选择器
    （英文）：
    如果（目标）{
      const disabled = isTeleportDisabled（vnode.props）;
      const targetNode = target._lpa || target.firstChild;
      如果 (vnode.shapeFlag & 16) {
        如果（已禁用）{
          vnode.anchor = hydrateChildren（
            下一个兄弟（节点），
            虚拟节点，
            父节点（节点），
            父组件，
            父级悬念，
            slotScopeIds，
            优化
          （英文）：
          vnode.target开始 = 目标节点;
          vnode.targetAnchor = 目标节点 && nextSibling(目标节点);
        } 别的 {
          vnode.anchor = nextSibling(节点);
          让目标Anchor = 目标节点；
          while (目标锚点) {
            如果 (targetAnchor && targetAnchor.nodeType === 8) {
              if (targetAnchor.data === "传送起始锚点") {
                vnode.targetStart = 目标锚点；
              } else if (targetAnchor.data === “传送锚”）{
                vnode.目标锚点 = 目标锚点;
                目标._lpa = vnode.targetAnchor && nextSibling(vnode.targetAnchor);
                休息;
              }
            }
            目标锚点 = 下一个兄弟 (目标锚点);
          }
          如果 (!vnode.targetAnchor) {
            准备锚点（目标，vnode，创建文本，插入）；
          }
          为儿童补充水分(
            目标节点 && 下一个兄弟节点(目标节点),
            虚拟节点，
            目标，
            父组件，
            父级悬念，
            slotScopeIds，
            优化
          （英文）：
        }
      }
      更新CssVars（vnode，已禁用）；
    }
    返回 vnode.anchor && nextSibling(vnode.anchor);
  }
  const Teleport = TeleportImpl;
  函数 updateCssVars (vnode，isDisabled) {
    const ctx = vnode.ctx;
    如果 (ctx && ctx.ut) {
      让节点，锚点；
      如果（已禁用）{
        节点 = vnode.el;
        锚点 = vnode.锚点；
      } 别的 {
        节点 = vnode.targetStart;
        锚点 = vnode.targetAnchor;
      }
      while (节点 && 节点 !== 锚点) {
        如果 (node.nodeType === 1) node.setAttribute("data-v-owner", ctx.uid);
        节点 = 节点.nextSibling;
      }
      ctx. ut()；
    }
  }
  函数 prepareAnchor (目标， vnode， createText， 插入) {
    const 目标开始 = vnode.目标开始 = 创建文本 (“”);
    const targetAnchor = vnode.targetAnchor = createText(“”);
    目标开始[TeleportEndKey] = 目标锚点；
    如果（目标）{
      插入（目标开始，目标）；
      插入（targetAnchor，目标）；
    }
    返回目标锚点；
  }

  const leaveCbKey = Symbol("_leaveCb");
  const enterCbKey$1 = 符号(“_enterCb”);
  函数 useTransitionState() {
    常量状态 = {
      是否已安装：false，
      是否离开：false，
      正在卸载：false，
      离开VNodes：/*@__PURE__*/new Map()
    };
    onMounted（（）=> {
      状态.isMounted = true;
    });
    onBeforeUnmount（（）=> {
      状态.正在卸载 = true;
    });
    返回状态；
  }
  const TransitionHookValidator = [函数，数组];
  const BaseTransitionPropsValidators = {
    模式：字符串，
    出现：布尔值，
    持久化：布尔值，
    // 进入
    onBeforeEnter: TransitionHookValidator，
    onEnter：TransitionHookValidator，
    onAfterEnter：TransitionHookValidator，
    onEnterCancelled：TransitionHookValidator，
    // 离开
    在离开之前：TransitionHookValidator，
    离开时：TransitionHookValidator，
    离开后：TransitionHookValidator，
    onLeaveCancelled：TransitionHookValidator，
    // 出现
    onBeforeAppear：TransitionHookValidator，
    出现：TransitionHookValidator，
    onAfterAppear：TransitionHookValidator，
    onAppearCancelled：TransitionHookValidator
  };
  const recursiveGetSubtree = (实例) => {
    const 子树 = 实例.子树;
    返回 subTree.component ? recursiveGetSubtree(subTree.component) : subTree;
  };
  const BaseTransitionImpl = {
    名称：`BaseTransition`，
    道具：BaseTransitionPropsValidators，
    设置（道具，{ 插槽 }）{
      const 实例 = 获取当前实例 ();
      const 状态 = useTransitionState();
      返回 () => {
        const children = slots.default && getTransitionRawChildren(slots.default(), true);
        如果 (!children || !children.length) {
          返回;
        }
        const child = findNonCommentChild(children);
        const rawProps = toRaw(props);
        const { 模式 } = rawProps;
        如果（模式&&模式！==“输入-输出”&&模式！==“输出-输入”&&模式！==“默认”）{
          警告$1(`无效的 <transition> 模式：${mode}`);
        }
        如果（状态.离开）{
          返回emptyPlaceholder（child）；
        }
        const innerChild = getInnerChild$1(child);
        如果 (!innerChild) {
          返回emptyPlaceholder（child）；
        }
        让 enterHooks = resolveTransitionHooks（
          内部子类，
          rawProps，
          状态，
          实例，
          // #11061，确保 clone 后 enterHooks 是新鲜的
          (hooks) => 输入Hooks = hooks
        （英文）：
        如果（innerChild.type！==注释）{
          setTransitionHooks(innerChild, EnterHooks);
        }
        让 oldInnerChild = instance.subTree && getInnerChild$1(instance.subTree);
        如果 (oldInnerChild && oldInnerChild.type !== 注释 && !isSameVNodeType(innerChild，oldInnerChild) && recursiveGetSubtree(instance).type !== 注释) {
          让 remainingHooks = resolveTransitionHooks(
            oldInnerChild，
            rawProps，
            状态，
            实例
          （英文）：
          setTransitionHooks(oldInnerChild, leftHooks);
          如果（mode ===“out-in”&& innerChild.type！==注释）{
            状态.是否离开 = true;
            离开Hooks.afterLeave = () => {
              状态.是否离开 = false;
              如果（！（instance.job.flags＆8））{
                实例.更新（）；
              }
              删除 LeaveHooks.afterLeave；
              旧的内部子对象 = 无效的 0;
            };
            返回emptyPlaceholder（child）；
          } 否则，如果 (mode === “in-out” && innerChild.type !== 注释) {
            离开Hooks.delayLeave = (el，earlyRemove，delayedLeave) => {
              const leaveVNodesCache = getLeavingNodesForType(
                状态，
                旧的内部子对象
              （英文）：
              离开VNodesCache[String(oldInnerChild.key)] = oldInnerChild;
              el[leaveCbKey] = () => {
                早期删除（）；
                el[leaveCbKey] = void 0;
                删除 enterHooks.delayedLeave；
                旧的内部子对象 = 无效的 0;
              };
              enterHooks.delayedLeave = () => {
                延迟离开（）；
                删除 enterHooks.delayedLeave；
                旧的内部子对象 = 无效的 0;
              };
            };
          } 别的 {
            旧的内部子对象 = 无效的 0;
          }
        }否则，如果（oldInnerChild）{
          旧的内部子对象 = 无效的 0;
        }
        返回孩子；
      };
    }
  };
  函数 findNonCommentChild(children) {
    让 child = children[0];
    如果 (children.length > 1) {
      让 hasFound = false;
      对于（子代的 const c）{
        如果（c.type！==注释）{
          如果（已找到）{
            警告$1(
              “<transition> 只能用于单个元素或组件。列表请使用 <transition-group>。”
            （英文）：
            休息;
          }
          孩子=c；
          已找到 = 真；
        }
      }
    }
    返回孩子；
  }
  const BaseTransition = BaseTransitionImpl;
  函数 getLeavingNodesForType(state，vnode) {
    const { 离开VNodes } = 状态；
    让leavingVNodesCache = leavesVNodes.get(vnode.type);
    如果（！leavingVNodesCache）{
      离开VNodesCache = /* @__PURE__ */ Object.create(null);
      离开VNodes.设置（vnode.type，离开VNodesCache）；
    }
    返回离开VNodesCache；
  }
  函数 resolveTransitionHooks (vnode， props， state， instance， postClone) {
    常量 {
      出现，
      模式，
      持续 = false，
      在进入之前，
      进入时，
      进入后，
      进入取消时，
      在离开之前，
      离开时，
      在离开后，
      onLeaveCancelled，
      在出现之前，
      出现时，
      在出现后，
      onAppearCancelled
    } = 道具；
    const 键 = String(vnode.key);
    const leaveVNodesCache = getLeavingNodesForType(state， vnode);
    const callHook = (hook, args) => {
      钩子&&callWithAsyncErrorHandling（
        钩，
        实例，
        9，
        参数
      （英文）：
    };
    const callAsyncHook = (hook, args) => {
      const done = args[1];
      调用Hook（hook，args）；
      如果 (isArray (钩子)) {
        如果 (hook.every((hook2) => hook2.length <= 1)) 完成();
      } 否则，如果 (hook.length <= 1) {
        完毕（）;
      }
    };
    const 钩子 = {
      模式，
      坚持，
      进入之前 (el) {
        让 hook = onBeforeEnter;
        如果 (!state.isMounted) {
          如果（出现）{
            钩子 = onBeforeAppear || onBeforeEnter;
          } 别的 {
            返回;
          }
        }
        如果 (el[leaveCbKey]) {
          el[leaveCbKey](
            真的
            /* 已取消 */
          （英文）：
        }
        const 离开VNode = 离开VNodesCache[key];
        如果（离开VNode && isSameVNodeType（vnode，离开VNode）&&离开VNode.el [leaveCbKey]）{
          离开VNode.el[leaveCbKey]();
        }
        调用Hook（hook，[el]）；
      }，
      输入 (el) {
        让 hook = onEnter;
        让 afterHook = onAfterEnter;
        让 cancelHook = onEnterCancelled;
        如果 (!state.isMounted) {
          如果（出现）{
            钩子 = onAppear || onEnter;
            afterHook = onAfterAppear ||输入后；
            取消Hook = onAppearCancelled || onEnterCancelled;
          } 别的 {
            返回;
          }
        }
        让 called = false;
        const done = el[enterCbKey$1] = (已取消) => {
          如果（被调用）则返回；
          称为=真；
          如果（取消）{
            取消Hook（[el]）；
          } 别的 {
            调用Hook(afterHook， [el]);
          }
          如果（hooks.delayedLeave）{
            钩子.delayedLeave()；
          }
          el[输入CbKey$1] = void 0;
        };
        如果（钩子）{
          调用AsyncHook（hook，[el，done]）；
        } 别的 {
          完毕（）;
        }
      }，
      离开（el，删除）{
        const key2 = String(vnode.key);
        如果 (el[enterCbKey$1]) {
          el[输入CbKey$1](
            真的
            /* 已取消 */
          （英文）：
        }
        如果（状态为正在卸载）{
          返回删除（）；
        }
        调用Hook(onBeforeLeave， [el]);
        让 called = false;
        const done = el[leaveCbKey] = (已取消) => {
          如果（被调用）则返回；
          称为=真；
          消除（）;
          如果（取消）{
            调用Hook(onLeaveCancelled， [el]);
          } 别的 {
            调用Hook(onAfterLeave， [el]);
          }
          el[leaveCbKey] = void 0;
          如果（leavingVNodesCache[key2] === vnode）{
            删除leavingVNodesCache[key2]；
          }
        };
        离开VNodesCache[key2] = vnode;
        如果（离开时）{
          callAsyncHook(onLeave, [el, 完成]);
        } 别的 {
          完毕（）;
        }
      }，
      克隆（vnode2）{
        const hooks2 = resolveTransitionHooks(
          vnode2，
          道具，
          状态，
          实例，
          克隆后
        （英文）：
        if (postClone) postClone(hooks2);
        返回 hooks2;
      }
    };
    返回钩子；
  }
  函数emptyPlaceholder（vnode）{
    如果（isKeepAlive（vnode））{
      vnode = 克隆VNode（vnode）；
      vnode.children = 空;
      返回vnode；
    }
  }
  函数 getInnerChild$1(vnode) {
    如果（！isKeepAlive（vnode））{
      如果（isTeleport（vnode.type）&& vnode.children）{
        返回 findNonCommentChild(vnode.children);
      }
      返回vnode；
    }
    如果（vnode.component）{
      返回 vnode.component.subTree；
    }
    const { shapeFlag， children } = vnode；
    如果（孩子）{
      如果 (shapeFlag & 16) {
        返回孩子[0]；
      }
      如果 (shapeFlag & 32 && isFunction(children.default)) {
        返回 children.default()；
      }
    }
  }
  函数 setTransitionHooks（vnode，hooks）{
    如果 (vnode.shapeFlag & 6 && vnode.component) {
      vnode.转换 = 钩子;
      设置TransitionHooks（vnode.component.subTree，hooks）；
    } 否则，如果 (vnode.shapeFlag & 128) {
      vnode.ssContent.transition = hooks.clone(vnode.ssContent);
      vnode.ssFallback.转换 = hooks.克隆(vnode.ssFallback);
    } 别的 {
      vnode.转换 = 钩子;
    }
  }
  函数 getTransitionRawChildren(children，keepComment = false，parentKey) {
    让 ret = [];
    让 keyedFragmentCount = 0;
    对于（让 i = 0; i < children.length; i++）{
      让 child = children[i];
      const key = parentKey == null ? child.key : String(parentKey) + String(child.key != null ? child.key : i);
      如果 (child.type === 片段) {
        如果 (child.patchFlag & 128) keyedFragmentCount++;
        ret = ret.concat（
          获取TransitionRawChildren（child.children，keepComment，key）
        （英文）：
      } 否则，如果 (keepComment || child.type !== 评论) {
        ret.push(key != null ? cloneVNode(child， { key }) : child);
      }
    }
    如果 (keyedFragmentCount > 1) {
      对于（让 i = 0; i < ret.length; i++）{
        ret[i].补丁标志 = -2;
      }
    }
    返回 ret；
  }

  /*!#__无副作用__*/
  //@__无副作用__
  函数 defineComponent（选项，extraOptions）{
    返回 isFunction(options) ? (
      // #8236: 扩展调用和 options.name 访问被视为副作用
      // 由 Rollup 实现，所以我们必须将其包装在纯注释的 IIFE 中。
      /* @__PURE__ */ (() => extend({ name: options.name }, extraOptions, { setup: options }))()
    ） ： 选项;
  }

  函数 useId() {
    获取当前实例
    如果（一世）{
      返回 (i.appContext.config.idPrefix || "v") + "-" + i.ids[0] + i.ids[1]++;
    } 别的 {
      警告$1(
        当没有活动组件实例可关联时，会调用 useId()。
      （英文）：
    }
    返回 ””;
  }
  函数 markAsyncBoundary(实例) {
    实例.ids = [实例.ids[0] + 实例.ids[2]++ + "-", 0, 0];
  }

  const knownTemplateRefs = /* @__PURE__ */ new WeakSet();
  函数 useTemplateRef (key) {
    获取当前实例
    var r = shallowRef(null);
    如果（一世）{
      const refs = i.refs === EMPTY_OBJ ? i.refs = {} : i.refs;
      让降序；
      如果 ((desc = Object.getOwnPropertyDescriptor(refs, key)) && !desc.configurable) {
        警告$1(`useTemplateRef('${key}') 已经存在。`);
      } 别的 {
        Object.defineProperty(refs, key, {
          可枚举： true，
          获取： () => r.value，
          设置：（val）=> r.value = val
        });
      }
    } 别的 {
      警告$1(
        当没有可关联的活动组件实例时，将调用 useTemplateRef()。
      （英文）：
    }
    var ret = 只读 (r)；
    {
      已知模板引用.添加（ret）；
    }
    返回 ret；
  }

  函数 setRef(rawRef，oldRawRef，parentSuspense，vnode，isUnmount = false) {
    如果 (isArray (rawRef)) {
      rawRef.forEach(
        (r，i) => 设置Ref(
          r，
          oldRawRef && (isArray(oldRawRef) ? oldRawRef[i] : oldRawRef),
          父级悬念，
          虚拟节点，
          卸载
        ）
      （英文）：
      返回;
    }
    如果（isAsyncWrapper（vnode）&&！isUnmount）{
      如果 (vnode.shapeFlag & 512 && vnode.type.__asyncResolved && vnode.component.subTree.component) {
        设置Ref（rawRef，oldRawRef，parentSuspense，vnode.component.subTree）；
      }
      返回;
    }
    const refValue = vnode.shapeFlag & 4 ? getComponentPublicInstance(vnode.component) : vnode.el;
    const 值 = isUnmount ? null : refValue;
    const { i： 所有者， r： ref } = rawRef;
    如果（！所有者）{
      警告$1(
        “缺少 ref 所有者上下文。ref 不能用于提升的 vnode。必须在渲染函数内创建具有 ref 的 vnode。”
      （英文）：
      返回;
    }
    const oldRef = oldRawRef && oldRawRef.r;
    const refs = Owner.refs === EMPTY_OBJ ? Owner.refs = {} : Owner.refs;
    const setupState = 所有者.setupState;
    const rawSetupState = toRaw(setupState);
    const canSetSetupRef = setupState === EMPTY_OBJ ? () => false : (key) => {
      {
        如果 (hasOwn(rawSetupState，key) && !isRef(rawSetupState[key])) {
          警告$1(
            “模板引用“${key}”用于非引用值。它不会在生产版本中起作用。”
          （英文）：
        }
        如果 (knownTemplateRefs.has(rawSetupState[key])) {
          返回 false；
        }
      }
      返回 hasOwn(rawSetupState，key);
    };
    如果 (oldRef != null && oldRef !== ref) {
      如果 (isString(oldRef)) {
        refs[oldRef] = null;
        如果 (canSetSetupRef(oldRef)) {
          设置状态[oldRef] = 空;
        }
      } 否则，如果 (isRef(oldRef)) {
        旧Ref.值 = 空；
      }
    }
    如果 (isFunction(ref)) {
      callWithErrorHandling（ref，所有者，12，[value，refs]）；
    } 别的 {
      引用:
      const _isRef = isRef(ref);
      如果 (_isString || _isRef) {
        const doSet = () => {
          如果（rawRef.f）{
            const 现有 = _isString ？ canSetSetupRef (ref) ？ setupState [ref] ： refs [ref] ： ref.value;
            如果（isUnmount）{
              isArray（现有）&& 删除（现有，refValue）；
            } 别的 {
              如果 (!isArray(存在)) {
                如果 (_isString) {
                  refs[ref] = [ref值];
                  如果 (canSetSetupRef(ref)) {
                    设置状态[ref] = refs[ref];
                  }
                } 别的 {
                  ref.值 = [refValue];
                  如果（rawRef.k）refs [rawRef.k] = ref.value;
                }
              } 否则，如果 (!existing.includes(refValue)) {
                现有的.推送（refValue）；
              }
            }
          } 否则，如果 (_isString) {
            refs[ref] = 值;
            如果 (canSetSetupRef(ref)) {
              设置状态[ref] = 值；
            }
          } 否则，如果 (_isRef) {
            ref.值 = 值;
            如果（rawRef.k）refs [rawRef.k] = 值；
          } 别的 {
            warn$1("无效的模板引用类型：", ref, `(${typeof ref})`);
          }
        };
        如果（值）{
          doSet.id = -1;
          队列PostRenderEffect（doSet，parentSuspense）；
        } 别的 {
          设置（）；
        }
      } 别的 {
        warn$1("无效的模板引用类型：", ref, `(${typeof ref})`);
      }
    }
  }

  让 hasLoggedMismatchError = false;
  const logMismatchError = () => {
    如果 (hasLoggedMismatchError) {
      返回;
    }
    console.error("水合完成但包含不匹配的内容。");
    有记录不匹配错误 = 真；
  };
  const isSVGContainer = (container) => container.namespaceURI.includes("svg") && container.tagName !== "foreignObject";
  const isMathMLContainer = (container) => container.namespaceURI.includes("MathML");
  const getContainerType = (容器) => {
    如果（container.nodeType！== 1）返回void 0；
    如果（isSVGContainer（container））返回“svg”；
    如果（isMathMLContainer（container））返回“mathml”；
    返回 void 0；
  };
  const isComment = (node) => node.nodeType === 8;
  函数 createHydrationFunctions（rendererInternals）{
    常量 {
      mt：安装组件，
      p：补丁，
      o：{
        patchProp，
        创建文本，
        下一个兄弟姐妹，
        父节点，
        消除，
        插入，
        创建评论
      }
    } = 渲染器内部；
    const hydrate = (vnode, 容器) => {
      如果 (!container.hasChildNodes()) {
        警告$1(
          “尝试补充现有标记，但容器为空。改为执行完全安装。”
        （英文）：
        补丁（null，vnode，容器）；
        刷新后刷新Cbs()；
        容器._vnode = vnode;
        返回;
      }
      hydrateNode（容器.firstChild，vnode，null，null，null）；
      刷新后刷新Cbs()；
      容器._vnode = vnode;
    };
    const hydrateNode = (node, vnode, parentComponent, parentSuspense, slotScopeIds,optimized = false) => {
      优化 = 优化 || !!vnode.dynamicChildren;
      const isFragmentStart = isComment(node) && node.data === "[";
      const onMismatch = () => handleMismatch(
        节点，
        虚拟节点，
        父组件，
        父级悬念，
        slotScopeIds，
        是否开始
      （英文）：
      const { 类型， ref， shapeFlag， patchFlag } = vnode;
      让 domType = 节点.nodeType;
      vnode.el = 节点;
      {
        def（节点，“__vnode”，vnode，true）；
        def（节点，“__vueParentComponent”，parentComponent，true）；
      }
      如果 (patchFlag === -2) {
        优化=错误；
        vnode.dynamicChildren = 空;
      }
      让下一个节点 = 空；
      开关（类型）{
        案文：
          如果 (domType !== 3) {
            如果（vnode.children ===“”）{
              插入（vnode.el = createText（""，parentNode（node），node）；
              下一个节点 = 节点;
            } 别的 {
              下一个节点 = onMismatch();
            }
          } 别的 {
            如果（节点.数据！== vnode.children）{
              警告$1(
                `水合文本不匹配`，
                节点.parentNode，
                `
  - 在服务器上呈现：${JSON.stringify(
                节点数据
              ）}
  - 客户端预期：${JSON.stringify(vnode.children)}`
              （英文）：
              logMismatchError()；
              节点.数据 = vnode.children;
            }
            下一个节点 = 下一个兄弟节点（节点）；
          }
          休息;
        案例评论：
          如果 (isTemplateNode(节点)) {
            下一个节点 = 下一个兄弟节点（节点）；
            替换节点（
              vnode.el = 节点.内容.firstChild，
              节点，
              父组件
            （英文）：
          } 否则，如果 (domType !== 8 || isFragmentStart) {
            下一个节点 = onMismatch();
          } 别的 {
            下一个节点 = 下一个兄弟节点（节点）；
          }
          休息;
        案例静态：
          如果（isFragmentStart）{
            节点 = 下一个兄弟节点（节点）；
            dom类型 = 节点.节点类型;
          }
          如果 (domType === 1 || domType === 3) {
            下一个节点 = 节点;
            const needToAdoptContent = !vnode.children.length;
            对于（让 i = 0; i < vnode.staticCount; i++）{
              if (需要采用内容)
                vnode.children += nextNode.nodeType === 1 ?nextNode.outerHTML : nextNode.data;
              如果 (i === vnode.staticCount - 1) {
                vnode.anchor = 下一个节点;
              }
              下一个节点 = 下一个兄弟节点 (下一个节点);
            }
            返回 isFragmentStart ? nextSibling(nextNode) : nextNode;
          } 别的 {
            不匹配（）；
          }
          休息;
        案例片段：
          如果（！isFragmentStart）{
            下一个节点 = onMismatch();
          } 别的 {
            下一个节点 = hydrateFragment(
              节点，
              虚拟节点，
              父组件，
              父级悬念，
              slotScopeIds，
              优化
            （英文）：
          }
          休息;
        默认：
          如果 (shapeFlag & 1) {
            如果 ((domType !== 1 || vnode.type.toLowerCase() !== node.tagName.toLowerCase()) && !isTemplateNode(node)) {
              下一个节点 = onMismatch();
            } 别的 {
              下一个节点 = hydrateElement（
                节点，
                虚拟节点，
                父组件，
                父级悬念，
                slotScopeIds，
                优化
              （英文）：
            }
          } 否则，如果 (shapeFlag & 6) {
            vnode.slotScopeIds = slotScopeIds;
            const 容器=parentNode(节点);
            如果（isFragmentStart）{
              下一个节点 = 定位关闭锚点 (节点);
            } else if (isComment(node) && node.data === “传送开始”）{
              nextNode = locationClosingAnchor(node, node.data, "传送结束");
            } 别的 {
              下一个节点 = 下一个兄弟节点（节点）；
            }
            安装组件（
              虚拟节点，
              容器，
              无效的，
              父组件，
              父级悬念，
              获取容器类型（容器），
              优化
            （英文）：
            if (isAsyncWrapper(vnode) && !vnode.type.__asyncResolved) {
              让子树；
              如果（isFragmentStart）{
                子树 = 创建VNode（片段）；
                子树.anchor = 下一个节点?下一个节点.previousSibling:容器.lastChild;
              } 别的 {
                subTree = node.nodeType === 3 ?createTextVNode(“”) : createVNode(“div”);
              }
              子树.el = 节点;
              vnode.component.subTree = 子树；
            }
          } 否则，如果 (shapeFlag & 64) {
            如果 (domType !== 8) {
              下一个节点 = onMismatch();
            } 别的 {
              nextNode = vnode.type.hydrate（
                节点，
                虚拟节点，
                父组件，
                父级悬念，
                slotScopeIds，
                优化，
                渲染器内部，
                补水儿童
              （英文）：
            }
          } 否则，如果 (shapeFlag & 128) {
            nextNode = vnode.type.hydrate（
              节点，
              虚拟节点，
              父组件，
              父级悬念，
              获取容器类型（父节点（节点）），
              slotScopeIds，
              优化，
              渲染器内部，
              水合节点
            （英文）：
          } 别的 {
            warn$1("无效的 HostVNode 类型：", type, `(${typeof type})`);
          }
      }
      如果 (ref != null) {
        设置Ref（ref，null，parentSuspense，vnode）；
      }
      返回下一个节点；
    };
    const hydrateElement = (el, vnode, parentComponent, parentSuspense, slotScopeIds,optimized) => {
      优化 = 优化 || !!vnode.dynamicChildren;
      const { 类型， props， patchFlag， shapeFlag， dirs， transition } = vnode;
      const forcePatch = 类型 === “输入” || 类型 === “选项”;
      {
        如果（目录）{
          调用DirectiveHook（vnode，null，parentComponent，“创建”）；
        }
        让 needCallTransitionHooks = false;
        如果 (isTemplateNode(el)) {
          需要CallTransitionHooks = 需要Transition（
            无效的，
            // hydration 中不需要检查 parentSuspense
            过渡
          ) && 父组件 && 父组件.vnode.props && 父组件.vnode.props.appear;
          const 内容 = el.content.firstChild;
          如果 (需要CallTransitionHooks) {
            转换.进入之前（内容）；
          }
          替换节点（内容， el， 父组件）；
          vnode.el = el = 内容;
        }
        if (shapeFlag & 16 && // 如果元素有 innerHTML / textContent 则跳过
        ！（道具&&（道具.innerHTML ||道具.textContent）））{
          让下一个=hydrateChildren（
            el.firstChild，
            虚拟节点，
            埃尔，
            父组件，
            父级悬念，
            slotScopeIds，
            优化
          （英文）：
          让 hasWarned = false;
          while (下一个) {
            如果 (!isMismatchAllowed(el，1 /* 儿童 */)) {
              如果 (!hasWarned) {
                警告$1(
                  ``儿童补水不匹配''，
                  埃尔，
                  `
服务器渲染的元素比客户端 vdom 包含更多的子节点。`
                （英文）：
                已警告 = 真；
              }
              logMismatchError()；
            }
            const cur = 下一个;
            下一个=下一个.下一个兄弟；
            删除（cur）；
          }
        } 否则，如果 (shapeFlag & 8) {
          让客户端文本 = vnode.children;
          if (clientText[0] === "\n" && (el.tagName === "PRE" || el.tagName === "TEXTAREA")) {
            客户端文本 = 客户端文本.切片（1）；
          }
          如果 (el.textContent !== 客户端文本) {
            如果 (!isMismatchAllowed(el, 0 /* 文本 */)) {
              警告$1(
                `Hydration 文本内容不匹配',
                埃尔，
                `
  - 在服务器上呈现：${el.textContent}
  - 客户端预期：${vnode.children}`
              （英文）：
              logMismatchError()；
            }
            el.textContent = vnode.children;
          }
        }
        如果（道具）{
          {
            const isCustomElement = el.tagName.includes(“-”);
            对于（props中的const键）{
              if (//#11189 如果此节点具有已创建钩子的指令，则跳过
              // 因为它可能以任何可能的方式改变 DOM
              !(dirs && dirs.some((d) => d.dir.created)) && propHasMismatch(el，key，props[key]，vnode，parentComponent)) {
                logMismatchError()；
              }
              if (forcePatch && (key.endsWith("value") || key === "indeterminate") || isOn(key) && !isReservedProp(key) || // 使用 .prop 修饰符强制水合 v-bind
              键[0] === "." || isCustomElement) {
                patchProp(el， key， null， props[key]， void 0， parentComponent);
              }
            }
          }
        }
        让 vnodeHooks；
        如果（vnodeHooks = props && props.onVnodeBeforeMount）{
          调用VNodeHook（vnodeHooks，parentComponent，vnode）；
        }
        如果（目录）{
          调用DirectiveHook（vnode，null，parentComponent，“beforeMount”）；
        }
        如果（（vnodeHooks = props && props.onVnodeMounted）|| dirs || needCallTransitionHooks）{
          队列效果与悬念（）=> {
            vnodeHooks && invokeVNodeHook(vnodeHooks， parentComponent， vnode);
            需要CallTransitionHooks && transition.enter(el);
            目录&&invokeDirectiveHook(vnode，null，parentComponent，“mounted”);
          }，父Suspense);
        }
      }
      返回 el.nextSibling；
    };
    const hydrateChildren = (node, parentVNode, container, parentComponent, parentSuspense, slotScopeIds,optimized) => {
      优化 = 优化 || !!parentVNode.dynamicChildren;
      const children = parentVNode.children;
      const l = children.length;
      让 hasWarned = false;
      对于（设 i = 0; i < l; i++）{
        const vnode = 优化？children[i] : children[i] = normalizeVNode(children[i]);
        const isText = vnode.type === Text;
        如果（节点）{
          如果 (isTe xt && !optimized) {
            如果 (i + 1 < l && normalizeVNode(children[i + 1]).type === Text) {
              插入（
                创建文本（
                  节点.数据.切片（vnode.children.长度）
                ),
                容器，
                下一个兄弟（节点）
              （英文）：
              节点.数据 = vnode.children;
            }
          }
          节点 = 水合节点（
            节点，
            虚拟节点，
            父组件，
            父级悬念，
            slotScopeIds，
            优化
          （英文）：
        } 否则，如果 (isText && !vnode.children) {
          插入（vnode.el = createText（""，容器）；
        } 别的 {
          如果 (!isMismatchAllowed(容器，1 /* 儿童 */)) {
            如果 (!hasWarned) {
              警告$1(
                ``儿童补水不匹配''，
                容器，
                `
服务器渲染的元素包含的子节点比客户端 vdom 少。`
              （英文）：
              已警告 = 真；
            }
            logMismatchError()；
          }
          修补（
            无效的，
            虚拟节点，
            容器，
            无效的，
            父组件，
            父级悬念，
            获取容器类型（容器），
            slotScopeIds
          （英文）：
        }
      }
      返回节点；
    };
    const hydrateFragment = (node, vnode, parentComponent, parentSuspense, slotScopeIds,optimized) => {
      const { slotScopeIds:fragmentSlotScopeIds } = vnode;
      如果 (fragmentSlotScopeIds) {
        片段SlotScopeIds
      }
      const 容器=parentNode(节点);
      const next = hydrateChildren（
        下一个兄弟（节点），
        虚拟节点，
        容器，
        父组件，
        父级悬念，
        slotScopeIds，
        优化
      （英文）：
      如果 (next && isComment(next) && next.data === "]") {
        返回 nextSibling(vnode.anchor = next);
      } 别的 {
        logMismatchError()；
        插入（vnode.anchor = createComment（`]`），容器，下一个）；
        返回下一步；
      }
    };
    const handleMismatch = (node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragment) => {
      如果 (!isMismatchAllowed(node.parentElement，1 /* 子元素 */)) {
        警告$1(
          `水合节点不匹配：
- 在服务器上呈现:`，
          节点，
          node.nodeType === 3 ? `(文本)` : isComment(节点) && node.data === "[" ? `(片段开始)` : ``,
          `
- 客户端预期：`，
          vnode.类型
        （英文）：
        logMismatchError()；
      }
      vnode.el = 空;
      如果（是Fragment）{
        const end = locationClosingAnchor（节点）；
        while (真) {
          const next2 = nextSibling(node);
          如果（next2 && next2 !== 结束）{
            删除（下一个2）；
          } 别的 {
            休息;
          }
        }
      }
      const next = nextSibling（节点）；
      const 容器=parentNode(节点);
      删除（节点）；
      修补（
        无效的，
        虚拟节点，
        容器，
        下一个，
        父组件，
        父级悬念，
        获取容器类型（容器），
        slotScopeIds
      （英文）：
      如果（父组件）{
        ParentComponent.vnode.el = vnode.el;
        更新HOCHostEl（parentComponent，vnode.el）；
      }
      返回下一步；
    };
    const locatedClosingAnchor = (node, open = "[", close = "]") => {
      让匹配=0；
      while (节点) {
        节点 = 下一个兄弟节点（节点）；
        如果 (节点 && isComment(节点)) {
          如果（node.data === open）匹配++；
          如果（节点.数据===关闭）{
            如果 (匹配 === 0) {
              返回下一个兄弟节点（节点）；
            } 别的 {
              匹配 - ;
            }
          }
        }
      }
      返回节点；
    };
    const replaceNode = (新节点， 旧节点， 父组件) => {
      constparentNode2 = oldNode.parentNode;
      如果 (父节点2) {
        父节点2.replaceChild(新节点，旧节点);
      }
      让父组件 = 父组件；
      while (父级) {
        如果 (parent.vnode.el === oldNode) {
          父节点.vnode.el = 父节点.subTree.el = 新节点;
        }
        父母=父母。父母；
      }
    };
    const isTemplateNode = (节点) => {
      返回节点.nodeType === 1 && 节点.tagName === “TEMPLATE”;
    };
    返回 [hydrate, hydrateNode];
  }
  函数 propHasMismatch(el，key，clientValue，vnode，instance) {
    让 mismatchType；
    让 mismatchKey；
    让实际；
    让预期；
    如果 (键 === “类”) {
      实际 = el.getAttribute("class");
      预期=normalizeClass（clientValue）;
      如果 (!isSetEqual(toClassSet(实际 || ""), toClassSet(预期))) {
        不匹配类型 = 2 /* 类 */;
        mismatchKey = `类`;
      }
    }否则，如果（键===“样式”）{
      实际 = el.getAttribute("style") || "";
      预期 = isString(clientValue) ? clientValue : stringifyStyle(normalizeStyle(clientValue));
      const actualMap = toStyleMap(实际);
      const expectedMap = toStyleMap(预期);
      如果（vnode.dirs）{
        for (const { dir, value } of vnode.dirs) {
          如果 (dir.name === “显示” && !值) {
            预期地图.设置（“显示”，“无”）；
          }
        }
      }
      如果（实例）{
        resolveCssVars（实例，vnode，expectedMap）；
      }
      如果（！isMapEqual（实际地图，预期地图））{
        不匹配类型 = 3 /* 风格 */;
        mismatchKey = “风格”;
      }
    } 否则，如果 (el instanceof SVGElement && isKnownSvgAttr(key) || el instanceof HTMLElement && (isBooleanAttr(key) || isKnownHtmlAttr(key))) {
      如果 (isBooleanAttr(key)) {
        实际 = el.hasAttribute(key);
        预期 = 包含布尔值 (clientValue);
      } 否则，如果 (clientValue == null) {
        实际 = el.hasAttribute(key);
        预期=错误；
      } 别的 {
        如果 (el.hasAttribute(key)) {
          实际 = el.getAttribute(key);
        } 否则，如果 (key === “value” && el.tagName === “TEXTAREA”) {
          实际 = el.值；
        } 别的 {
          实际=错误；
        }
        预期 = isRenderableAttrValue(clientValue) ? 字符串(clientValue) : false;
      }
      如果（实际！==预期）{
        mismatchType = 4 /* 属性 */;
        不匹配键 = 键；
      }
    }
    如果 (mismatchType != null && !isMismatchAllowed(el, mismatchType)) {
      const format = (v) => v === false ? `(未呈现)` : `${mismatchKey}="${v}"`;
      const preSegment = `Hydration ${MismatchTypeString[mismatchType]} 不匹配`;
      const postSegment = `
  - 在服务器上呈现：${format(actual)}
  - 客户端预期：${format(expected)}
  注意：此不匹配仅用于检查。由于性能开销，DOM 不会在生产中得到纠正。
  您应该修复不匹配的根源。`;
      {
        warn$1(preSegment, el, postSegment);
      }
      返回 true；
    }
    返回 false；
  }
  函数 toClassSet(str) {
    返回新的 Set(str.trim().split(/\s+/));
  }
  函数 isSetEqual(a，b) {
    如果 (a.大小 !== b.大小) {
      返回 false；
    }
    对于（a 的 const s）{
      如果 (!b.有(s)) {
        返回 false；
      }
    }
    返回 true；
  }
  函数 toStyleMap(str) {
    const styleMap = /* @__PURE__ */ new Map();
    对于（str.split（“;”）的const项）{
      让 [key，value] = item.split(“：”);
      键 = 键.trim()；
      值 = 值 && 值.trim();
      如果 (键 && 值) {
        styleMap.设置（键，值）；
      }
    }
    返回样式地图；
  }
  函数 isMapEqual(a，b) {
    如果 (a.大小 !== b.大小) {
      返回 false；
    }
    for (const [键，值] 的 a) {
      如果 (值 !== b.get(key)) {
        返回 false；
      }
    }
    返回 true；
  }
  函数 resolveCssVars (实例， vnode， expectedMap) {
    const 根 = 实例.子树;
    如果 (instance.getCssVars && (vnode === root || root && root.type === Fragment && root.children.includes(vnode))) {
      const cssVars = 实例.getCssVars();
      对于（cssVars 中的 const 键）{
        预期地图.设置（
          `--${getEscapedCssVarName(key)}`，
          字符串（cssVars[key]）
        （英文）：
      }
    }
    如果 (vnode === root && 实例.parent) {
      解析CssVars（实例.parent，实例.vnode，预期地图）；
    }
  }
  const allowMismatchAttr = "数据允许不匹配";
  const MismatchTypeString = {
    [0 /* 文本 */]: "文本",
    [1 /* 孩子 */]：“孩子”，
    [2 /* 类别 */]: "类别",
    [3 /* 风格 */]: “风格”,
    [4 /* 属性 */]：“属性”
  };
  函数 isMismatchAllowed（el，allowedType）{
    如果 (allowedType === 0 /* 文本 */ || allowedType === 1 /* 儿童 */) {
      while (el && !el.hasAttribute(allowMismatchAttr)) {
        el = el.父元素；
      }
    }
    声明一个允许的Attr属性，然后使用getAttribute()方法获取该属性的值。
    如果 (allowedAttr == null) {
      返回 false；
    } 否则，如果 (allowedAttr ===“”) {
      返回 true；
    } 别的 {
      const 列表 = allowedAttr.split(“,”);
      如果 (allowedType === 0 /* TEXT */ && list.includes("children")) {
        返回 true；
      }
      返回 allowedAttr.split("，").includes(MismatchTypeString[allowedType]);
    }
  }

  const requestIdleCallback = getGlobalThis().requestIdleCallback || ((cb) => setTimeout(cb， 1));
  const cancelIdleCallback = getGlobalThis().cancelIdleCallback || ((id) => clearTimeout(id));
  const hydrateOnIdle = (timeout = 1e4) => (hydrate) => {
    const id = requestIdleCallback（hydrate， { 超时 }）;
    返回（）=>取消IdleCallback（id）；
  };
  函数元素IsVisibleInViewport（el）{
    const { 上，左，下，右 } = el.getBoundingClientRect();
    const { innerHeight， innerWidth } = 窗口；
    返回 (顶部 > 0 && 顶部 < innerHeight || 底部 > 0 && 底部 < innerHeight) && (左侧 > 0 && 左侧 < innerWidth || 右侧 > 0 && 右侧 < innerWidth);
  }
  const hydrateOnVisible = (opts) => (hydrate, forEach) => {
    const ob = new IntersectionObserver((entries) => {
      for (条目的 const e) {
        如果（！e.isIntersecting）继续；
        断开连接（）；
        水合物（）；
        休息;
      }
    }，选择）；
    forEach((el) => {
      如果（！（el instanceof Element））返回；
      如果 (elementIsVisibleInViewport(el)) {
        水合物（）；
        断开连接（）；
        返回 false；
      }
      ob.观察(el);
    });
    返回 () => ob.disconnect();
  };
  const hydrateOnMediaQuery = (查询) => (hydrate) => {
    如果（查询）{
      const mql = matchMedia（查询）；
      如果 (mql.匹配) {
        水合物（）；
      } 别的 {
        mql.addEventListener("改变", hydrate, { once: true });
        返回 () => mql.removeEventListener("change", hydrate);
      }
    }
  };
  const hydrateOnInteraction = (interactions = []) => (hydrate, forEach) => {
    如果（isString（交互））交互 = [交互];
    让 hasHydrated = false;
    const doHydrate = (e) => {
      如果 (!hasHydrated) {
        已水合 = 真；
        拆卸（）；
        水合物（）；
        e.target.dispatchEvent（新e.构造函数（e.type，e））；
      }
    };
    const 拆卸 = () => {
      forEach((el) => {
        对于（交互的 const i）{
          el.removeEventListener(i, doHydrate);
        }
      });
    };
    forEach((el) => {
      对于（交互的 const i）{
        el.addEventListener（i，doHydrate，{once：true}）；
      }
    });
    返回拆卸；
  };
  函数 forEachElement（节点，cb）{
    如果（isComment（node）&& node.data ===“[”）{
      让深度=1；
      让下一个 = 节点.nextSibling；
      while (下一个) {
        如果 (下一个节点类型 === 1) {
          const 结果 = cb(下一个);
          如果 (结果 === false) {
            休息;
          }
        } 否则，如果（isComment（下一个））{
          如果（下一个数据 === “]”）{
            如果 (--depth === 0) 中断；
          } 否则，如果 (next.data === “[”) {
            深度++；
          }
        }
        下一个=下一个.下一个兄弟；
      }
    } 别的 {
      cb(节点);
    }
  }

  const isAsyncWrapper = (i) => !!i.type.__asyncLoader;
  /*!#__无副作用__*/
  //@__无副作用__
  函数 defineAsyncComponent（源）{
    如果（isFunction（源））{
      源 = { 加载器： 源 };
    }
    常量 {
      装载机，
      loadingComponent，
      错误组件，
      延迟 = 200，
      水合物：水合物策略，
      暂停，
      // undefined = 永不超时
      可暂停 = true，
      onError：用户错误
    } = 来源；
    让待处理请求 = 空；
    让 solvedComp；
    让重试 = 0；
    const 重试 = () => {
      重试++；
      待处理请求 = 空；
      返回负载（）；
    };
    const 负载 = () => {
      让这个请求；
      返回未决请求 || (thisRequest = 未决请求 = loader().catch((err) => {
        err = err 实例of Error ? err : new Error(String(err));
        如果（用户出错）{
          返回新的 Promise((resolve, rejection) => {
            const userRetry = () => resolve(retry());
            const userFail = () => 拒绝(err);
            userOnError（错误， userRetry， userFail， 重试 + 1）；
          });
        } 别的 {
          抛出错误；
        }
      }).then((比较) => {
        如果 (此请求 !== 待处理请求 && 待处理请求) {
          返回待处理的请求；
        }
        如果（！comp）{
          警告$1(
            `异步组件加载器解析为未定义。如果您使用 retry()，请确保返回其返回值。`
          （英文）：
        }
        如果 (comp && (comp.__esModule || comp[Symbol.toStringTag] === "Module")) {
          comp = comp.默认;
        }
        如果 (comp && !isObject(comp) && !isFunction(comp)) {
          抛出新的错误（`无效的异步组件加载结果：${comp}`）；
        }
        已解析Comp = comp;
        退货政策
      }））；
    };
    返回 defineComponent({
      名称：“AsyncComponentWrapper”，
      __asyncLoader：加载，
      __asyncHydrate（el，实例，水合物）{
        const doHydrate = hydrateStrategy ? () => {
          const 拆卸 = hydrateStrategy（
            保湿，
            （cb）=> forEachElement（el，cb）
          （英文）：
          如果（拆卸）{
            (instance.bum || (instance.bum = [])).推(拆卸);
          }
        } ：水合物；
        如果 (resolvedComp) {
          执行水合物（）；
        } 别的 {
          加载（）。然后（（）=>！实例。isUnmounted&&doHydrate（））；
        }
      }，
      获取 __asyncResolved() {
        返回已解析的Comp；
      }，
      设置（） {
        const 实例 = 当前实例;
        标记AsyncBoundary（实例）；
        如果 (resolvedComp) {
          返回（）=> createInnerComp（resolvedComp，实例）；
        }
        const onError = (err) => {
          待处理请求 = 空；
          错误处理（
            犯错，
            实例，
            13，
            !错误组件
          （英文）：
        };
        如果 (suspensible && instance.suspense || false) {
          返回 load().then((comp) => {
            返回 () => createInnerComp(comp，instance);
          }).catch((错误) => {
            错误发生（错误）；
            返回 () => 错误组件 ? createVNode(错误组件， {
              错误： 错误
            }） ： 无效的;
          });
        }
        var ref = false; //加载成功
        const 错误 = ref();
        const 延迟 = ref(!!延迟);
        如果（延迟）{
          设置超时（（）=> {
            延迟.值=false；
          }， 延迟）;
        }
        如果（超时！= null）{
          设置超时（（）=> {
            如果 (!loaded.value && !error.value) {
              const err = new Error(
                `异步组件在 ${timeout}ms 后超时。`
              （英文）：
              错误发生（错误）；
              错误.值 = 错误;
            }
          }， 暂停）;
        }
        加载().然后(() => {
          已加载.值 = true;
          如果（instance.parent && isKeepAlive（instance.parent.vnode））{
            实例.parent.update()；
          }
        }).catch((错误) => {
          错误发生（错误）；
          错误.值 = 错误;
        });
        返回 () => {
          如果（loaded.value && solvedComp）{
            返回 createInnerComp（resolvedComp，实例）；
          } 否则，如果 (错误.值 && 错误组件) {
            返回 createVNode（errorComponent，{
              错误：error.value
            });
          } 否则，如果 (loadingComponent && !delayed.value) {
            返回 createVNode(loadingComponent);
          }
        };
      }
    });
  }
  函数 createInnerComp（comp，parent）{
    const { ref: ref2, props, children, ce } = parent.vnode;
    const vnode = createVNode(comp, props, children);
    vnode.ref = ref2;
    vnode.ce = ce;
    删除parent.vnode.ce；
    返回vnode；
  }

  const isKeepAlive = (vnode) => vnode.type.__isKeepAlive;
  const KeepAliveImpl = {
    名称：`KeepAlive`，
    // 渲染器内部特殊处理的标记。我们不使用 ===
    // 直接在渲染器中检查 KeepAlive，因为直接导入它
    // 将阻止它被 tree-shaking 。
    __isKeepAlive：是的，
    道具：{
      包括：[字符串，正则表达式，数组]，
      排除：[字符串，正则表达式，数组]，
      最大值：[字符串，数字]
    }，
    设置（道具，{ 插槽 }）{
      const 实例 = 获取当前实例 ();
      const 共享上下文 = 实例.ctx;
      const cache = /* @__PURE__ */ new Map();
      const keys = /* @__PURE__ */ new Set();
      让当前 = 空；
      {
        实例.__v_cache = 缓存；
      }
      const parentSuspense = 实例.suspense;
      常量 {
        渲染器：{
          p：补丁，
          m：移动，
          嗯：_卸载，
          o：{ 创建元素 }
        }
      } = 共享上下文；
      const storageContainer = createElement("div");
      sharedContext.activate = (vnode, 容器, 锚点, 命名空间, 优化) => {
        const 实例2 = vnode.component;
        移动（vnode，容器，锚点，0，parentSuspense）；
        修补（
          实例2.vnode，
          虚拟节点，
          容器，
          锚，
          实例2，
          父级悬念，
          命名空间，
          vnode.slotScopeIds，
          优化
        （英文）：
        队列后渲染效果（）=> {
          instance2.isDeactivated = false;
          如果（实例2.a）{
            调用ArrayFns（实例2.a）；
          }
          const vnodeHook = vnode.props && vnode.props.onVnodeMounted;
          如果（vnodeHook）{
            调用VNodeHook（vnodeHook，instance2.parent，vnode）；
          }
        }，父Suspense);
        {
          devtoolsComponentAdded（实例2）；
        }
      };
      sharedContext.deactivate = (vnode) => {
        const 实例2 = vnode.component;
        无效安装（实例2.m）；
        invalidateMount（实例2.a）；
        移动（vnode，storageContainer，null，1，parentSuspense）；
        队列后渲染效果（）=> {
          如果（实例2.da）{
            调用ArrayFns（实例2.da）；
          }
          const vnodeHook = vnode.props && vnode.props.onVnodeUnmounted;
          如果（vnodeHook）{
            调用VNodeHook（vnodeHook，instance2.parent，vnode）；
          }
          instance2.isDeactivated = true;
        }，父Suspense);
        {
          devtoolsComponentAdded（实例2）；
        }
      };
      函数卸载（vnode）{
        重置形状标志（vnode）；
        _unmount（vnode，实例，parentSuspense，true）；
      }
      函数 pruneCache（过滤器）{
        缓存.forEach((vnode，key) => {
          const 名称 = 获取组件名称（vnode.类型）；
          如果 (名称 && !过滤器 (名称)) {
            修剪CacheEntry（键）；
          }
        });
      }
      函数 pruneCacheEntry(key) {
        const 缓存 = 缓存.get(key);
        如果 (缓存 && (!当前 || !isSameVNodeType(缓存，当前))) {
          卸载（缓存）；
        } 否则，如果（当前）{
          重置形状标志（当前）；
        }
        缓存.删除（键）；
        键.删除（键）；
      }
      手表（
        () => [props.include，props.exclude]，
        ([包括，排除]) => {
          包括 && pruneCache((name) => 匹配(包括，名称));
          排除 && pruneCache((name) => !matches(exclude, name));
        }，
        // 在 `current` 更新后修剪后渲染
        { 刷新：“post”，deep：true }
      （英文）：
      让 pendatingCacheKey = null;
      const cacheSubtree = () => {
        如果 (pendingCacheKey != null) {
          如果（isSuspense（instance.subTree.type））{
            队列后渲染效果（）=> {
              缓存.设置（pendingCacheKey，getInnerChild（实例.subTree））；
            }, 实例.subTree.suspense);
          } 别的 {
            缓存.设置（pendingCacheKey，getInnerChild（实例.subTree））；
          }
        }
      };
      onMounted（缓存子树）；
      onUpdated（缓存子树）；
      onBeforeUnmount（（）=> {
        缓存.forEach((缓存) => {
          const { subTree， suspense } = 实例；
          const vnode = getInnerChild(subTree);
          如果 (cached.type === vnode.type && cached.key === vnode.key) {
            重置形状标志（vnode）；
            const da = vnode.component.da;
            da &&queuePostRenderEffect(da, 悬念);
            返回;
          }
          卸载（缓存）；
        });
      });
      返回 () => {
        待处理缓存键 = 空;
        如果（！slots.default）{
          返回当前=空；
        }
        const children = slots.default();
        const rawVNode = children[0];
        如果 (children.length > 1) {
          {
            warn$1(`KeepAlive 应该只包含一个子组件。`);
          }
          当前=空；
          返回孩子；
        } 否则，如果 (!isVNode(rawVNode) || !(rawVNode.shapeFlag & 4) && !(rawVNode.shapeFlag & 128)) {
          当前=空；
          返回 rawVNode；
        }
        让 vnode = getInnerChild(rawVNode);
        如果（vnode.type === 注释）{
          当前=空；
          返回vnode；
        }
        const comp = vnode.type;
        const 名称 = 获取组件名称（
          isAsyncWrapper(vnode) ？ vnode.type.__asyncResolved || {}：比较
        （英文）：
        const { 包括， 排除， 最大值 } = props;
        如果 (包括 && (!name || !matches(include, name)) || 排除 && name && matches(exclude, name)) {
          vnode.shapeFlag &= ~256;
          当前=vnode；
          返回 rawVNode；
        }
        const key = vnode.key == null ? comp : vnode.key;
        const cachedVNode = cache.get(key);
        如果（vnode.el）{
          vnode = 克隆VNode（vnode）；
          如果 (rawVNode.shapeFlag & 128) {
            rawVNode.ss内容 = vnode;
          }
        }
        待处理缓存键 = 键；
        如果（缓存VNode）{
          vnode.el = 缓存的VNode.el;
          vnode.组件 = 缓存的VNode.组件;
          如果（vnode.transition）{
            setTransitionHooks(vnode, vnode.transition);
          }
          vnode.形状标志 |= 512;
          键.删除（键）；
          键.添加（键）；
        } 别的 {
          键.添加（键）；
          如果 (max && keys.size > parseInt(max, 10)) {
            pruneCacheEntry（keys.values（）。next（）。值）；
          }
        }
        vnode.形状标志|= 256;
        当前=vnode；
        返回 isSuspense(rawVNode.type) ？原始VNode：v节点；
      };
    }
  };
  const KeepAlive = KeepAliveImpl;
  函数匹配（模式，名称）{
    如果 (isArray (模式)) {
      返回模式.some((p) => matches(p, name));
    } 否则，如果 (isString (模式)) {
      返回模式.split（“，”）.includes（名称）；
    } 否则，如果 (isRegExp(模式)) {
      模式.lastIndex = 0;
      返回模式.测试（名称）；
    }
    返回 false；
  }
  函数 onActivated（钩子，目标）{
    注册KeepAliveHook（钩子，“a”，目标）；
  }
  函数 onDeactivated (hook，target) {
    注册KeepAliveHook（hook，“da”，目标）；
  }
  函数 registerKeepAliveHook（hook，类型，目标 = currentInstance）{
    const surrounded by hooks.__wdc || (hook.__wdc = () => {
      让当前=目标；
      while (当前) {
        如果（current.isDeactivated）{
          返回;
        }
        当前=当前.父级；
      }
      返回钩子（）；
    });
    注入Hook（类型，wrappedHook，目标）；
    如果（目标）{
      让当前 = 目标.父级；
      while (当前 && 当前.父级) {
        如果（isKeepAlive（current.parent.vnode））{
          injectionToKeepAliveRoot（wrappedHook，类型，目标，当前）；
        }
        当前=当前.父级；
      }
    }
  }
  函数injectToKeepAliveRoot（钩子，类型，目标，keepAliveRoot）{
    const 注入 = injectionHook（
      类型，
      钩，
      keepAliveRoot，
      真的
      /* 添加 */
    （英文）：
    onUnmounted（（）=> {
      删除（keepAliveRoot [类型]，注入）；
    }， 目标）;
  }
  函数 resetShapeFlag(vnode) {
    vnode.shapeFlag &= ~256;
    vnode.shapeFlag &= ~512;
  }
  函数 getInnerChild (vnode) {
    返回 vnode.shapeFlag & 128 ? vnode.ssContent : vnode;
  }

  函数injectHook（类型，钩子，目标=currentInstance，prepend=false）{
    如果（目标）{
      const 钩子 = 目标[类型] || (目标[类型] = []);
      const surrounded by hooks = hook.__weh || (hook.__weh = (...args) => {
        暂停跟踪（）；
        const 重置 = 设置当前实例 (目标);
        const res = callWithAsyncErrorHandling（钩子， 目标， 类型， 参数）；
        重置（）;
        重置跟踪（）；
        返回 res；
      });
      如果（前置）{
        钩子.unshift（wrappedHook）；
      } 别的 {
        钩子.推（wrappedHook）；
      }
      返回wrappedHook；
    } 别的 {
      const apiName = toHandlerKey(ErrorTypeStrings$1[type].replace(/ hook$/, “”));
      警告$1(
        `当没有要关联的活动组件实例时，将调用 ${apiName}。生命周期注入 API 只能在 setup() 执行期间使用。` + (` 如果您使用异步 setup()，请确保在第一个 await 语句之前注册生命周期钩子。` )
      （英文）：
    }
  }
  const createHook = (生命周期) => (钩子，目标 = 当前实例) => {
    如果 (!isInSSRComponentSetup || 生命周期 === "sp") {
      注入Hook（生命周期，（...args）=>钩子（...args），目标）；
    }
  };
  const onBeforeMount = createHook(“bm”);
  const onMounted = createHook (“m”);
  const onBeforeUpdate = createHook(
    “不”
  （英文）：
  const onUpdated = createHook(“u”);
  const onBeforeUnmount = createHook(
    “屁股”
  （英文）：
  const onUnmounted = createHook(“嗯”);
  const onServerPrefetch = createHook（
    “sp”
  （英文）：
  const onRenderTriggered = createHook("rtg");
  const onRenderTracked = createHook("rtc");
  函数 onErrorCaptured（hook，target = currentInstance）{
    注入Hook（“ec”，钩子，目标）；
  }

  const COMPONENTS = “组件”;
  const DIRECTIVES = “指令”;
  函数 resolveComponent (名称，maybeSelfReference) {
    返回 resolveAsset(COMPONENTS, name, true, maybeSelfReference) || name;
  }
  const NULL_DYNAMIC_COMPONENT = 符号.for("v-ndc");
  函数 resolveDynamicComponent (组件) {
    如果（isString（组件））{
      返回 resolveAsset(COMPONENTS， component，false) || component;
    } 别的 {
      返回组件 || NULL_DYNAMIC_COMPONENT;
    }
  }
  函数 resolveDirective (名称) {
    返回 resolveAsset（DIRECTIVES，名称）；
  }
  函数 resolveAsset(类型，名称，warnMissing = true，maybeSelfReference = false) {
    const 实例 = currentRenderingInstance || 当前实例;
    如果（实例）{
      const 组件 = 实例.类型;
      如果 (类型 === 组件) {
        const selfName = getComponentName（
          成分，
          错误的
        （英文）：
        如果 (selfName && (selfName === name || selfName === camelize(name) || selfName === capitalize(camelize(name)))) {
          返回组件；
        }
      }
      const res = （
        // 本地注册
        // 首先检查实例[类型]，它已解析选项 API
        resolve(instance[type] || Component[type], name) || // 全局注册
        解析（实例.appContext [类型]，名称）
      （英文）：
      如果 (!res && perhapsSelfReference) {
        返回组件；
      }
      如果 (warnMissing && !res) {
        const extra = 类型 === 组件？`
如果这是本机自定义元素，请确保通过compilerOptions.isCustomElement将其从组件解析中排除。`：``;
        警告$1(`无法解析${type.slice(0, -1)}: ${name}${extra}`);
      }
      返回 res；
    } 别的 {
      警告$1(
        `resolve${capitalize(type.slice(0, -1))} 只能在 render() 或 setup() 中使用。`
      （英文）：
    }
  }
  函数解析（注册表，名称）{
    返回注册表 && (注册表[名称] || 注册表[camelize(名称)] || 注册表[capitalize(camelize(名称))]);
  }

  函数renderList（源，renderItem，缓存，索引）{
    让 ret;
    const 缓存 = 缓存 && 缓存[索引];
    const 源IsArray = isArray(源);
    如果 (sourceIsArray || isString(source)) {
      const 源IsReactiveArray = 源IsArray && isReactive(源);
      让 needsWrap = false;
      如果 (sourceIsReactiveArray) {
        需要Wrap = ！isShallow（源）；
        源 = shallowReadArray(源);
      }
      ret = 新数组（源.长度）;
      对于（让 i = 0，l = 源.length; i < l; i++）{
        ret[i] = renderItem(
          需要包裹吗？ toReactive(源[i]) : 源[i],
          我，
          无效 0，
          缓存 && 缓存[i]
        （英文）：
      }
    } 否则，如果 (typeof source === “number”) {
      如果 (!Number.isInteger(source)) {
        warn$1(`v-for 范围需要一个整数值但得到的是 ${source}。`);
      }
      ret = 新数组（源）；
      对于（让 i = 0; i < 源; i++）{
        ret[i] = renderItem(i + 1, i, void 0, 缓存 && cached[i]);
      }
    } 否则，如果 (isObject(source)) {
      如果（源[Symbol.iterator]）{
        ret = 数组.from(
          来源，
          (item，i) => renderItem(item，i，void 0，缓存&&缓存[i])
        （英文）：
      } 别的 {
        const 键 = Object.keys(源);
        ret = 新数组（keys.length）;
        对于（让 i = 0，l = keys.length; i < l; i++）{
          const 键 = 键[i];
          ret[i] = renderItem(source[key], key, i, 缓存 && 缓存[i]);
        }
      }
    } 别的 {
      ret = [];
    }
    如果（缓存）{
      缓存[索引] = ret;
    }
    返回 ret；
  }

  函数 createSlots（slots，dynamicSlots）{
    对于（让 i = 0；i < dynamicSlots.length；i++）{
      const 槽 = dynamicSlots[i];
      如果（isArray（插槽））{
        对于（设 j = 0；j < 槽位长度；j++）{
          插槽[插槽[j].名称] = 插槽[j].fn;
        }
      } 否则，如果（槽）{
        插槽[插槽.名称] = 插槽.键？（...参数）=> {
          const res = slot.fn(...args);
          如果（res）res.key = slot.key;
          返回 res；
        } ： 插槽.fn；
      }
    }
    返回时段；
  }

  函数 renderSlot(slots, name, props = {}, fallback, noSlotted) {
    如果 (currentRenderingInstance.ce || currentRenderingInstance.parent && isAsyncWrapper(currentRenderingInstance.parent) && currentRenderingInstance.parent.ce) {
      如果（name！==“default”）props.name = name;
      返回 openBlock(), createBlock(
        分段，
        无效的，
        [createVNode("slot", props, fallback && fallback())],
        64
      （英文）：
    }
    让 slot = slots[name];
    如果 (槽 && 槽.长度 > 1) {
      警告$1(
        `在非 SSR 优化的渲染函数中检测到了 SSR 优化的插槽函数。您需要在父模板中使用 $dynamic-slots 标记此组件。`
      （英文）：
      槽 = () => [];
    }
    如果 (插槽 && 插槽._c) {
      插槽._d = 假;
    }
    打开块（）；
    const validSlotContent = slot && 确保ValidVNode(slot(props));
    const slotKey = props.key || // 动态条件插槽的插槽内容数组可能有一个分支
    // 附加在 `createSlots` 助手中的键，尊重这一点
    有效SlotContent && 有效SlotContent.key;
    const render = createBlock(
      分段，
      {
        key: (slotKey && !isSymbol(slotKey) ? slotKey : `_${name}`) + // #7256 强制区分后备内容和实际内容
        （！validSlotContent && 后备？“_fb”：“”）
      }，
      validSlotContent || （回退？回退（）：[]），
      validSlotContent && slots._ === 1 ? 64 : -2
    （英文）：
    如果 (!noSlotted && rendered.scopeId) {
      render.slotScopeIds = [rendered.scopeId + “-s”];
    }
    如果 (插槽 && 插槽._c) {
      槽._d = 真;
    }
    返回呈现；
  }
  函数确保有效VNode（vnodes）{
    返回 vnodes.some((child) => {
      如果 (!isVNode(child)) 返回 true；
      如果 (child.type === Comment) 返回 false;
      如果 (child.type === Fragment && !ensureValidVNode(child.children))
        返回 false；
      返回 true；
    }）？vnodes：空；
  }

  函数 toHandlers(obj，preserveCaseIfNecessary) {
    常量 ret = {};
    如果 (!isObject(obj)) {
      warn$1(`没有参数的 v-on 需要一个对象值。`);
      返回 ret；
    }
    for (obj 中的 const 键) {
      ret[preserveCaseIfNecessary && /[AZ]/.test(key) ? `on:${key}` : toHandlerKey(key)] = obj[key];
    }
    返回 ret；
  }

  const getPublicInstance = （i）=> {
    如果（！i）则返回null；
    如果（isStatefulComponent（i））返回getComponentPublicInstance（i）；
    返回 getPublicInstance(i.parent);
  };
  const publicPropertiesMap = （
    // 将 PURE 标记移至新行，以避免编译器丢弃它
    // 由于类型注释
    /* @__PURE__ */ 扩展（/* @__PURE__ */ Object.create（null），{
      $: (一世) => 我,
      $el: (i) => i.vnode.el,
      $数据：（i）=> i.数据，
      $props: (i) => shallowReadonly(i.props),
      $attrs: (i) => shallowReadonly(i.attrs),
      $slots: (i) => shallowReadonly(i.slots),
      $refs: (i) => shallowReadonly(i.refs) ，
      $parent: (i) => 获取公共实例(i.parent),
      $root: (i) => 获取PublicInstance(i.root),
      $主机：（i）=> i.ce，
      $emit: (i) => i.emit,
      $选项：（i）=> resolveMergedOptions（i），
      $forceUpdate: (i) => 如果 || (如果 = () => {
        队列作业（i.更新）；
      }),
      $nextTick：（i）=> 在||（在=nextTick.bind（i.proxy）），
      $watch: (i) => instanceWatch.bind(i)
    }）
  （英文）：
  const isReservedPrefix = (key) => key === “_” || key === “$”;
  const hasSetupBinding = (state, key) => state !== EMPTY_OBJ && !state.__isScriptSetup && hasOwn(state, key);
  const PublicInstanceProxyHandlers = {
    获取（{ _：实例 }，键）{
      如果 (键 === “__v_skip”) {
        返回 true；
      }
      const { ctx，setupState，数据，props，accessCache，类型，appContext } = 实例；
      如果 (key === "__isVue") {
        返回 true；
      }
      让 normalizedProps；
      如果 (键[0] !== "$") {
        const n = 访问缓存[key];
        如果 (n !== void 0) {
          开关（n）{
            情况 1 /* 设置 */：
              返回setupState [key]；
            情况 2 /* 数据 */：
              返回数据[键]；
            案例 4 /* 上下文 */：
              返回 ctx[key];
            案例 3 /* PROPS */：
              返回 props[key];
          }
        } 否则，如果 (hasSetupBinding(setupState，key)) {
          accessCache[key] = 1 /* 设置 */;
          返回setupState [key]；
        } 否则，如果 (数据 !== EMPTY_OBJ && hasOwn(数据，键)) {
          访问缓存[key] = 2 /* 数据 */;
          返回数据[键]；
        }否则，如果（
          // 仅当实例已声明（因此稳定）时缓存其他属性
          // 道具
          （normalizedProps = instance.propsOptions[0]）&& hasOwn（normalizedProps，key）
        ）{
          accessCache[key] = 3 /* PROPS */;
          返回 props[key];
        } 否则，如果 (ctx !== EMPTY_OBJ && hasOwn(ctx，key)) {
          accessCache[key] = 4 /* 上下文 */;
          返回 ctx[key];
        }否则，如果（shouldCacheAccess）{
          accessCache[key] = 0 /* 其他 */;
        }
      }
      const publicGetter = publicPropertiesMap[key];
      让 cssModule，globalProperties；
      如果（公共Getter）{
        如果 (key === "$attrs") {
          跟踪（实例。属性，“获取”，“”）；
          标记属性访问情况（）；
        } 否则，如果 (key === "$slots") {
          跟踪（实例，“获取”，键）；
        }
        返回 publicGetter（实例）；
      }否则，如果（
        // css 模块（由 vue-loader 注入）
        （cssModule = 类型.__cssModules）&& （cssModule = cssModule[key]）
      ）{
        返回 cssModule；
      } 否则，如果 (ctx !== EMPTY_OBJ && hasOwn(ctx，key)) {
        accessCache[key] = 4 /* 上下文 */;
        返回 ctx[key];
      }否则，如果（
        // 全局属性
        globalProperties = appContext.config.globalProperties，hasOwn（globalProperties，键）
      ）{
        {
          返回全局属性[key]；
        }
      } else if (currentRenderingInstance && (!isString(key) || // #1091 避免在组件实例前进行内部 isRef/isVNode 检查
      // 进入无限警告循环
      键.索引（“__v”）！== 0））{
        如果 (数据 !== EMPTY_OBJ && isReservedPrefix(key[0]) && hasOwn(数据，key)) {
          警告$1(
            `属性 ${JSON.stringify(
            钥匙
          )} 必须通过 $data 访问，因为它以保留字符（“$”或“_”）开头，并且在渲染上下文中没有代理。`
          （英文）：
        } 否则，如果 (实例 === currentRenderingInstance) {
          警告$1(
            “属性 ${JSON.stringify(key)} 在渲染期间被访问但未在实例上定义。”
          （英文）：
        }
      }
    }，
    设置（{ _：实例 }，键，值）{
      const { 数据， setupState， ctx } = 实例；
      如果 (hasSetupBinding(setupState，key)) {
        设置状态[键] = 值;
        返回 true；
      } 否则，如果 (setupState.__isScriptSetup && hasOwn(setupState，key)) {
        warn$1(`无法从选项 API 中改变 <​​script setup> 绑定“${key}”。`);
        返回 false；
      } 否则，如果 (数据 !== EMPTY_OBJ && hasOwn(数据，键)) {
        数据[键] = 值;
        返回 true；
      } 否则，如果 (hasOwn(instance.props，key)) {
        warn$1(`试图改变 prop“${key}”。Props 是只读的。`);
        返回 false；
      }
      if (key[0] === "$" && key.slice(1) 在实例中) {
        警告$1(
          `尝试改变公共属性“${key}”。以 $ 开头的属性是保留的且是只读的。`
        （英文）：
        返回 false；
      } 别的 {
        如果（输入 instance.appContext.config.globalProperties）{
          Object.defineProperty（ctx，key，{
            可枚举： true，
            可配置： true，
            价值
          });
        } 别的 {
          ctx[键] = 值;
        }
      }
      返回 true；
    }，
    有（{
      _：{数据，setupState，accessCache，ctx，appContext，propsOptions}
    }， 钥匙） {
      让 normalizedProps；
      返回 !!accessCache[key] || data !== EMPTY_OBJ && hasOwn(data, key) || hasSetupBinding(setupState, key) || (normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key) || hasOwn(ctx, key) || hasOwn(publicPropertiesMap, key) || hasOwn(appContext.config.globalProperties, key);
    }，
    定义属性（目标，键，描述符）{
      如果（描述符.get != null）{
        目标._.accessCache[键] = 0;
      } 否则，如果（hasOwn（描述符，“值”））{
        this.set（目标，键，描述符。值，null）；
      }
      返回 Reflect.defineProperty(target, key, descriptor);
    }
  };
  {
    PublicInstanceProxyHandlers.ownKeys = (目标) => {
      警告$1(
        “避免使用依赖于枚举组件实例上的键的应用逻辑。在生产模式下，键将为空，以避免性能开销。”
      （英文）：
      返回 Reflect.ownKeys(target);
    };
  }
  const RuntimeCompiledPublicInstanceProxyHandlers = /* @__PURE__ */ extend({}, PublicInstanceProxyHandlers, {
    获取（目标，键）{
      如果 (key === Symbol.unscopables) {
        返回;
      }
      返回 PublicInstanceProxyHandlers.get(target, key, target);
    }，
    有（_，键）{
      const has = key[0] !== “_” && !isGloballyAllowed(key);
      如果 (!has && PublicInstanceProxyHandlers.has(_, key)) {
        警告$1(
          `属性 ${JSON.stringify(
          钥匙
        )} 不应以 _ 开头，因为 _ 是 Vue 内部的保留前缀。`
        （英文）：
      }
      返回有；
    }
  });
  函数 createDevRenderContext（实例）{
    const 目标 = {};
    Object.defineProperty（目标，`_`，{
      可配置： true，
      可枚举：false，
      获取：（）=> 实例
    });
    对象.keys（publicPropertiesMap）.forEach（（key）=> {
      Object.defineProperty（目标，键，{
        可配置： true，
        可枚举：false，
        获取：（）=> publicPropertiesMap[key](实例)，
        // 被代理拦截，因此无需实现，
        // 但需要防止设置错误
        设置：NOOP
      });
    });
    返回目标；
  }
  函数 revealPropsOnRenderContext(实例) {
    常量 {
      ctx，
      道具选项：[道具选项]
    } = 实例；
    如果（道具选项）{
      对象.keys(propsOptions).forEach((key) => {
        Object.defineProperty（ctx，key，{
          可枚举： true，
          可配置： true，
          获取：（）=> instance.props[key]，
          设置：NOOP
        });
      });
    }
  }
  函数暴露SetupStateOnRenderContext（实例）{
    const { ctx，setupState } = 实例；
    对象.keys(toRaw(setupState)).forEach((key) => {
      如果 (!setupState.__isScriptSetup) {
        如果（isReservedPrefix（key[0]））{
          警告$1(
            `setup() 返回属性 ${JSON.stringify(
            钥匙
          )} 不应以“$”或“_”开头，因为它们是 Vue 内部的保留前缀。`
          （英文）：
          返回;
        }
        Object.defineProperty（ctx，key，{
          可枚举： true，
          可配置： true，
          获取：（）=>setupState[key]，
          设置：NOOP
        });
      }
    });
  }

  const warnRuntimeUsage = (方法) => warn$1(
    “${method}() 是一个编译器提示助手，只能在单个文件组件的 <script setup> 内使用。它的参数应该被编译掉，并且在运行时传递它不会产生任何效果。”
  （英文）：
  函数 defineProps() {
    {
      警告运行时使用（`defineProps`）；
    }
    返回空值；
  }
  函数 defineEmits() {
    {
      警告运行时使用情况（`defineEmits`）；
    }
    返回空值；
  }
  函数 defineExpose（暴露）{
    {
      警告运行时使用情况（`defineExpose`）；
    }
  }
  函数 defineOptions（选项）{
    {
      警告运行时使用情况（`defineOptions`）；
    }
  }
  函数 defineSlots() {
    {
      警告运行时使用情况（`defineSlots`）；
    }
    返回空值；
  }
  函数 defineModel() {
    {
      警告运行时使用情况(“defineModel”);
    }
  }
  函数 withDefaults（props，默认值）{
    {
      警告运行时使用情况（`withDefaults`）；
    }
    返回空值；
  }
  函数 useSlots() {
    返回 getContext().slots;
  }
  函数 useAttrs() {
    返回 getContext().attrs;
  }
  函数 getContext() {
    获取当前实例
    如果（！我）{
      warn$1(`useContext() 在没有活动实例的情况下被调用。`);
    }
    返回 i.setupContext || (i.setupContext = createSetupContext(i));
  }
  函数 normalizePropsOrEmits (props) {
    返回 isArray(props) ? props.reduce(
      (标准化，p) => (标准化[p] = 空，标准化)
      {}
    ): 道具；
  }
  函数mergeDefaults（原始，默认值）{
    const props = normalizePropsOrEmits(raw);
    for（默认值中的 const 键）{
      如果（key.startsWith（“__skip”））继续；
      让 opt = props[key];
      如果（选择）{
        如果 (isArray (opt) || isFunction (opt)) {
          opt = props[key] = { 类型：opt， 默认值：defaults[key] };
        } 别的 {
          opt.default = 默认值[key];
        }
      } 否则，如果 (opt === null) {
        opt = props[key] = { 默认值：默认值[key] };
      } 别的 {
        warn$1(`props 默认键“${key}”没有相应的声明。`);
      }
      如果（opt && defaults[`__skip_${key}`]）{
        选择.skipFactory = true;
      }
    }
    返还道具；
  }
  函数合并模型（a，b）{
    如果（！a ||！b）返回a || b；
    if (isArray(a) && isArray(b)) return a.concat(b);
    返回延伸（{}，normalizePropsOrEmits（a），normalizePropsOrEmits（b））；
  }
  函数 createPropsRestProxy (props，excludedKeys) {
    常量 ret = {};
    对于（props中的const键）{
      如果（！excludedKeys.includes（key））{
        Object.defineProperty（ret，key，{
          可枚举： true，
          获取： () => props[key]
        });
      }
    }
    返回 ret；
  }
  函数 withAsyncContext(getAwaitable) {
    const ctx = 获取当前实例（）；
    如果（！ctx）{
      警告$1(
        “withAsyncContext 在没有活动当前实例的情况下被调用。这可能是一个错误。”
      （英文）：
    }
    让 awaitable = getAwaitable()；
    取消设置当前实例（）；
    如果 (isPromise(awaitable)) {
      可等待 = 可等待. 捕获（（e） => {
        设置当前实例（ctx）；
        抛出 e；
      });
    }
    返回 [awaitable, () => setCurrentInstance(ctx)];
  }

  函数 createDuplicateChecker() {
    const 缓存 = /* @__PURE__ */ Object.create(null);
    返回（类型，键）=> {
      如果 (缓存 [键]) {
        warn$1(`${type} 属性 "${key}" 已在 ${cache[key]} 中定义。`);
      } 别的 {
        缓存[键] = 类型；
      }
    };
  }
  让 shouldCacheAccess = true;
  函数applyOptions（实例）{
    const 选项 = resolveMergedOptions(实例);
    const publicThis = 实例.proxy;
    const ctx = 实例.ctx;
    应该缓存访问 = false;
    如果（选项。创建之前）{
      callHook$1（options.beforeCreate，实例，“bc”）；
    }
    常量 {
      // 状态
      数据：数据选项，
      计算：计算选项，
      方法，
      观看：观看选项，
      提供：提供选项，
      注入：注入选项，
      // 生命周期
      创建，
      在挂载之前，
      安装，
      更新前，
      已更新，
      活性，
      已停用，
      销毁之前，
      卸载之前，
      被毁坏，
      卸载，
      使成为，
      渲染跟踪，
      渲染触发，
      错误捕获，
      服务器预取，
      // 公共 API
      暴露，
      继承属性，
      // 资产
      成分，
      指令，
      过滤器
    } = 选项；
    复制代码
    {
      const [propsOptions] = 实例.propsOptions;
      如果（道具选项）{
        对于（propsOptions中的const键）{
          checkDuplicateProperties("Props" /* PROPS */, 键);
        }
      }
    }
    如果（注入选项）{
      解析注入（注入选项，ctx，检查重复属性）；
    }
    如果（方法）{
      for（方法中的 const 键）{
        const 方法处理程序 = 方法[key];
        如果 (isFunction(methodHandler)) {
          {
            Object.defineProperty（ctx，key，{
              值：methodHandler.bind（publicThis），
              可配置： true，
              可枚举： true，
              可写： true
            });
          }
          {
            checkDuplicateProperties("方法" /* 方法 */, 键);
          }
        } 别的 {
          警告$1(
            “方法“${key}”在组件定义中具有类型“${typeof methodHandler}”。您是否正确引用了该函数？“
          （英文）：
        }
      }
    }
    如果（数据选项）{
      如果（！isFunction（数据选项））{
        警告$1(
          “数据选项必须是一个函数。不再支持普通对象的使用。”
        （英文）：
      }
      const 数据 = 数据选项.调用（publicThis， publicThis）;
      如果（isPromise（数据））{
        警告$1(
          `data() 返回了一个 Promise——注意 data() 不能是异步的；如果您打算在组件渲染之前执行数据提取，请使用异步 setup() + <Suspense>。`
        （英文）：
      }
      如果 (!isObject(数据)) {
        warn$1(`data() 应该返回一个对象。`);
      } 别的 {
        实例.数据 = 反应性（数据）;
        {
          for（数据中的 const 键）{
            checkDuplicateProperties("数据" /* 数据 */, 键);
            如果 (!isReservedPrefix(key[0])) {
              Object.defineProperty（ctx，key，{
                可配置： true，
                可枚举： true，
                获取：（）=> 数据[键]，
                设置：NOOP
              });
            }
          }
        }
      }
    }
    应该缓存访问 = true;
    如果（计算选项）{
      对于（computedOptions中的const键）{
        const opt = computedOptions[key];
        const get = isFunction(opt)?opt.bind(publicThis，publicThis) : isFunction(opt.get)?opt.get.bind(publicThis，publicThis) : NOOP;
        如果（获取 === NOOP）{
          warn$1(`计算属性“${key}”没有 getter。`);
        }
        const set = !isFunction(opt) && isFunction(opt.set) ? opt.set.bind(publicThis) : () => {
          警告$1(
            `写入操作失败：计算属性“${key}”是只读的。`
          （英文）：
        }；
        const c = 计算（{
          得到，
          放
        });
        Object.defineProperty（ctx，key，{
          可枚举： true，
          可配置： true，
          获取： () => c.value,
          设置：（v）=> c.value = v
        });
        {
          checkDuplicateProperties("计算" /* 计算 */, 键);
        }
      }
    }
    如果（观察选项）{
      对于（watchOptions 中的 const 键）{
        创建Watcher（watchOptions [key]，ctx，publicThis，key）；
      }
    }
    如果（提供选项）{
      const 提供 = isFunction（提供选项）？提供选项.call（publicThis）：提供选项；
      Reflect.ownKeys（提供）。forEach（（key）=> {
        提供（密钥，提供[密钥]）；
      });
    }
    如果（创建）{
      callHook$1(创建，实例，“c”);
    }
    函数registerLifecycleHook（注册，钩子）{
      如果 (isArray (钩子)) {
        hook.forEach((_hook) => 注册(_hook.bind(publicThis)));
      } 否则，如果（钩子）{
        注册（hook.bind（publicThis））；
      }
    }
    注册LifecycleHook（onBeforeMount，beforeMount）；
    注册LifecycleHook（onMounted，mounted）；
    注册LifecycleHook（onBeforeUpdate，beforeUpdate）；
    注册LifecycleHook（onUpdated，更新）；
    注册LifecycleHook（onActivated，已激活）；
    注册LifecycleHook（onDeactivated，已停用）；
    注册LifecycleHook（onErrorCaptured，errorCaptured）；
    registerLifecycleHook(onRenderTracked, renderTracked);
    registerLifecycleHook(onRenderTriggered, renderTriggered);
    注册LifecycleHook（在卸载之前，在卸载之前）；
    注册LifecycleHook（onUnmounted，卸载）；
    注册LifecycleHook（onServerPrefetch，serverPrefetch）；
    如果 (isArray (暴露)) {
      如果（暴露.长度）{
        const exposed = 实例.exposed || (实例.exposed = {});
        暴露.forEach((key) => {
          Object.defineProperty（暴露，键，{
            获取：（）=> publicThis[key]，
            设置：（val）=> publicThis[key] = val
          });
        });
      } 否则，如果（！实例.暴露）{
        实例.暴露 = {};
      }
    }
    如果 (渲染 && 实例.渲染 === NOOP) {
      实例.render = 渲染;
    }
    如果 (inheritAttrs != null) {
      实例.inheritAttrs = inheritAttrs;
    }
    如果（组件）实例.components = components;
    如果（指令）实例.指令=指令；
  }
  函数 resolveInjections(injectOptions，ctx，checkDuplicateProperties = NOOP) {
    如果（isArray（注入选项））{
      注入选项 = 正常化注入 (注入选项);
    }
    对于（injectOptions中的const键）{
      const opt = 注入选项[key];
      让注入；
      如果（isObject（opt））{
        if (opt 中的“默认”) {
          注入 = 注入（
            opt.from || 键，
            选择默认，
            真的
          （英文）：
        } 别的 {
          注入 = 注入（opt.from || key）;
        }
      } 别的 {
        注入=注入（选择）；
      }
      如果 (isRef(注入)) {
        Object.defineProperty（ctx，key，{
          可枚举： true，
          可配置： true，
          获取：（）=>注入.值，
          设置：（v）=>注入的值=v
        });
      } 别的 {
        ctx[key] = 注入；
      }
      {
        checkDuplicateProperties("注入" /* 注入 */, key);
      }
    }
  }
  函数调用Hook$1(钩子，实例，类型) {
    调用异步错误处理（
      isArray(hook) ? hook.map((h) => h.bind(instance.proxy)) : hook.bind(instance.proxy),
      实例，
      类型
    （英文）：
  }
  函数 createWatcher（raw，ctx，publicThis，key）{
    让 getter = key.includes(“.”) ?createPathGetter(publicThis, key) : () => publicThis[key];
    如果（isString（原始））{
      const 处理程序 = ctx[raw];
      如果（isFunction（处理程序））{
        {
          监视（吸气剂，处理程序）；
        }
      } 别的 {
        warn$1(`键“${raw}”指定的监视处理程序无效`, handler);
      }
    } 否则，如果 (isFunction(raw)) {
      {
        观察（getter，raw.bind（publicThis））；
      }
    } 否则，如果 (isObject(raw)) {
      如果（isArray（原始））{
        raw.forEach((r) => createWatcher(r， ctx， publicThis， key));
      } 别的 {
        const handler = isFunction(raw.handler) ?raw.handler.bind(publicThis) : ctx[raw.handler];
        如果（isFunction（处理程序））{
          观察（吸气剂，处理程序，原始）；
        } 别的 {
          warn$1(`键“${raw.handler}”指定的监视处理程序无效`, handler);
        }
      }
    } 别的 {
      warn$1(`无效的监视选项：“${key}”`, raw);
    }
  }
  函数 resolveMergedOptions (实例) {
    const base = 实例.类型;
    const { mixins， 扩展： extendsOptions } = base;
    常量 {
      mixins：globalMixins，
      optionsCache：缓存，
      配置：{ 选项合并策略 }
    } = 实例.appContext;
    const 缓存 = cache.get(base);
    让解决；
    如果（缓存）{
      已解析=已缓存；
    } 否则，如果 (!globalMixins.length && !mixins && !extendsOptions) {
      {
        已解决=基础；
      }
    } 别的 {
      已解决 = {};
      如果（globalMixins.length）{
        globalMixins.forEach(
          （m）=> 合并选项（已解决，m，optionMergeStrategies，true）
        （英文）：
      }
      合并选项（已解决，基础，选项合并策略）；
    }
    如果 (isObject(base)) {
      缓存.设置（基础，已解析）；
    }
    返回已解决；
  }
  函数合并选项（到，从，strats，asMixin = false）{
    const { mixins， 扩展： extendsOptions } = from;
    如果（扩展选项）{
      合并选项（至，扩展选项，策略，true）；
    }
    如果（混合）{
      mixins.forEach(
        （m）=> 合并选项（至，m，策略，true）
      （英文）：
    }
    for（const 键来自）{
      如果 (asMixin && key === “expose”) {
        警告$1(
          “在 mixins 或 extends 中声明时，会忽略“expose”选项。它只能在基础组件本身中声明。”
        （英文）：
      } 别的 {
        const strat = internalOptionMergeStrats[key] || strats && strats[key];
        到[key] = strat ? strat(到[key], 从[key]) : 从[key];
      }
    }
    返回；
  }
  const internalOptionMergeStrats = {
    数据：mergeDataFn，
    道具：mergeEmitsOrPropsOptions，
    发出：mergeEmitsOrPropsOptions，
    // 对象
    方法：mergeObjectOptions，
    计算：mergeObjectOptions，
    // 生命周期
    beforeCreate:mergeAsArray$1，
    创建：mergeAsArray$1，
    beforeMount:mergeAsArray$1，
    已安装：mergeAsArray$1，
    更新前：mergeAsArray$1，
    更新：mergeAsArray$1，
    beforeDestroy：mergeAsArray$1，
    beforeUnmount:mergeAsArray$1，
    销毁：mergeAsArray$1，
    卸载：mergeAsArray$1，
    激活：mergeAsArray$1，
    停用：mergeAsArray$1，
    错误捕获：mergeAsArray$1，
    serverPrefetch: mergeAsArray$1,
    // 资产
    组件：mergeObjectOptions，
    指令：mergeObjectOptions，
    // 手表
    观察：mergeWatchOptions，
    // 提供/注入
    提供：mergeDataFn，
    注入：mergeInject
  };
  函数mergeDataFn（到，从）{
    如果（！来自）{
      返回；
    }
    如果（！至）{
      从...返回；
    }
    返回函数 mergedDataFn() {
      返回（扩展）（
        isFunction(to) ? to.call(this, this) : to,
        isFunction(from) ? from.call(this, this) : from
      （英文）：
    };
  }
  函数mergeInject（到，来自）{
    返回mergeObjectOptions（normalizeInject（to），normalizeInject（from））；
  }
  函数 normalizeInject(raw) {
    如果（isArray（原始））{
      常量 res = {};
      对于（让 i = 0; i < raw.length; i++）{
        res[raw[i]] = raw[i];
      }
      返回 res；
    }
    返回原始；
  }
  函数mergeAsArray$1（到，从）{
    返回？[...new Set([].concat(to, from))] : from;
  }
  函数mergeObjectOptions（到，从）{
    返回到？扩展（/* @__PURE__ */ Object.create（null），to，from）：from；
  }
  函数mergeEmitsOrPropsOptions（到，从）{
    如果（至）{
      如果 (isArray (到) && isArray (从)) {
        返回 [.../* @__PURE__ */ new Set([...to, ...from])];
      }
      返回扩展（
        /* @__PURE__ */ Object.create(null),
        normalizePropsOrEmits（至），
        normalizePropsOrEmits（来自！= null？来自：{}）
      （英文）：
    } 别的 {
      从...返回；
    }
  }
  函数mergeWatchOptions（到，从）{
    如果（！）从返回；
    如果（！from）返回；
    const 合并 = 扩展（/* @__PURE__ */ Object.create（null），to）；
    for（const 键来自）{
      合并[key] = mergeAsArray$1(to[key], from[key]);
    }
    返回合并；
  }

  函数 createAppContext() {
    返回 {
      应用程序：null，
      配置：{
        isNativeTag: 否，
        表现：错误，
        全局属性：{}，
        选项合并策略：{}，
        错误处理程序：void 0，
        警告处理程序：void 0，
        编译器选项：{}
      }，
      混合：[]，
      成分： {}，
      指令：{}，
      提供：/*@__PURE__*/Object.create(null)，
      optionsCache：/*@__PURE__*/new WeakMap()，
      propsCache：/* @__PURE__ */ new WeakMap()，
      发出缓存：/* @__PURE__ */ new WeakMap()
    };
  }
  让 uid$1 = 0;
  函数 createAppAPI（渲染，水合物）{
    返回函数 createApp（rootComponent，rootProps = null）{
      如果 (!isFunction(rootComponent)) {
        rootComponent = 扩展（{}，rootComponent）；
      }
      如果 (rootProps != null && !isObject(rootProps)) {
        warn$1(`传递给 app.mount() 的根 props 必须是一个对象。`);
        rootProps = 空;
      }
      const 上下文 = createAppContext();
      const installedPlugins = /* @__PURE__ */ new WeakSet();
      const pluginCleanupFns = [];
      让 isMounted = false;
      const app = context.app = {
        _uid:uid$1++，
        _component：根组件，
        _props：根属性，
        _container：空，
        _context：上下文，
        _实例：null，
        版本，
        获取配置（）{
          返回 context.config；
        }，
        设置配置（v）{
          {
            警告$1(
              `app.config 无法替换。请修改个别选项。`
            （英文）：
          }
        }，
        使用（插件，...选项）{
          如果（installedPlugins.has（插件））{
            warn$1(`插件已应用于目标应用程序。`);
          } 否则，如果（插件 && isFunction（插件.install））{
            安装插件.添加（插件）；
            插件.安装（应用程序，...选项）；
          } 否则，如果（isFunction（插件））{
            安装插件.添加（插件）；
            插件（应用程序，...选项）；
          } 别的 {
            警告$1(
              `插件必须是一个函数或者一个具有“安装”功能的对象。`
            （英文）：
          }
          返回应用程序；
        }，
        混合（混合）{
          {
            如果（！context.mixins.includes（mixin））{
              上下文.mixins.push(mixin);
            } 别的 {
              警告$1(
                “Mixin 已应用于目标应用程序” + (mixin.name ? `: ${mixin.name}` : “”)
              （英文）：
            }
          }
          返回应用程序；
        }，
        组件（名称，组件）{
          {
            验证组件名称（名称，context.config）；
          }
          如果（！组件）{
            返回 context.components[name];
          }
          如果（上下文.组件[名称]）{
            warn$1(`组件“${name}”已在目标应用程序中注册。`);
          }
          context.components[名称] = 组件;
          返回应用程序；
        }，
        指令（名称，指令）{
          {
            验证指令名称（名称）；
          }
          如果（！指令）{
            返回 context.directives[name];
          }
          如果（context.directives [名称]）{
            warn$1(`指令“${name}”已在目标应用中注册。`);
          }
          context.directives[名称] = 指令;
          返回应用程序；
        }，
        安装（rootContainer，isHydrate，命名空间）{
          如果（！已安装）{
            如果 (rootContainer.__vue_app__) {
              警告$1(
                `主机容器上已安装一个应用程序实例。
 如果要在同一个主机容器上安装另一个应用程序，则需要先通过调用 \`app.unmount()\` 来卸载之前的应用程序。
              （英文）：
            }
            const vnode = app._ceVNode || 创建VNode(rootComponent，rootProps);
            vnode.appContext = 上下文；
            如果（命名空间 === true）{
              命名空间 = “svg”;
            } 否则，如果（命名空间 === false）{
              命名空间 = void 0;
            }
            {
              上下文.重新加载 = () => {
                使成为（
                  cloneVNode（vnode），
                  根容器，
                  命名空间
                （英文）：
              };
            }
            如果 (isHydrate && 水合物) {
              水合物（vnode，rootContainer）；
            } 别的 {
              渲染（vnode，rootContainer，命名空间）；
            }
            是否已安装 = 真；
            应用程序._container = 根容器;
            根容器.__vue_app__ = 应用程序;
            {
              应用程序._实例 = vnode.组件;
              devtoolsInitApp（应用程序，版本）；
            }
            返回 getComponentPublicInstance(vnode.component);
          } 别的 {
            警告$1(
              `应用程序已经安装。
如果您想重新安装同一个应用程序，请将您的应用程序创建逻辑移到工厂函数中，并为每个安装创建新的应用程序实例 - 例如 \`const createMyApp = () => createApp(App)\``
            （英文）：
          }
        }，
        onUnmount（cleanupFn）{
          如果 (typeof cleanupFn !== "function") {
            警告$1(
              `预期函数作为 app.onUnmount() 的第一个参数，但得到的是 ${typeof cleanupFn}`
            （英文）：
          }
          pluginCleanupFns.push（cleanupFn）；
        }，
        卸载（）{
          如果（已安装）{
            调用异步错误处理（
              pluginCleanupFns，
              应用程序._实例，
              16
            （英文）：
            渲染（null，app._container）；
            {
              应用程序._实例 = 空;
              devtoolsUnmountApp（应用程序）；
            }
            删除 app._container.__vue_app__;
          } 别的 {
            警告$1（`无法卸载未安装的应用程序。`）；
          }
        }，
        提供（键，值）{
          如果（输入 context.provides）{
            警告$1(
              `应用程序已提供带有键“${String(key)}”的属性。它将被新值覆盖。`
            （英文）：
          }
          上下文.提供[键] = 值；
          返回应用程序；
        }，
        运行上下文（fn）{
          const lastApp = currentApp;
          当前应用程序 = 应用程序；
          尝试 {
            返回 fn()；
          } 最后 {
            当前应用程序 = 最后一个应用程序；
          }
        }
      };
      返回应用程序；
    };
  }
  让 currentApp = null;

  函数提供（键，值）{
    如果 (!当前实例) {
      {
        warn$1(`provide() 只能在 setup() 内部使用。`);
      }
    } 别的 {
      让提供 = 当前实例.提供；
      const parentProvides = currentInstance.parent && currentInstance.parent.provides;
      如果 (parentProvides === 提供) {
        提供 = 当前实例.提供 = 对象.创建 (parentProvides);
      }
      提供[键] = 值；
    }
  }
  函数注入（key，defaultValue，treatDefaultAsFactory = false）{
    const 实例 = 当前实例 || 当前渲染实例;
    如果 (实例 || currentApp) {
      const 提供 = currentApp ? currentApp._context.provides : 实例 ? instance.parent == null ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides : void 0;
      如果 (提供 && 输入提供) {
        返回提供[key]；
      } 否则，如果 (参数.长度 > 1) {
        返回 treatDefaultAsFactory && isFunction(defaultValue) ? defaultValue.call(instance && instance.proxy) : defaultValue;
      } 别的 {
        警告$1(`未找到注入“${String(key)}”。`);
      }
    } 别的 {
      warn$1(`inject() 只能在 setup() 或功能组件内部使用。`);
    }
  }
  函数 hasInjectionContext() {
    返回！（currentInstance || currentRenderingInstance || currentApp）；
  }

  const internalObjectProto = {};
  const createInternalObject = () => Object.create(internalObjectProto);
  const isInternalObject = (obj) => Object.getPrototypeOf(obj) === internalObjectProto;

  函数 initProps（实例，rawProps，isStateful，isSSR = false）{
    const props = {};
    声明一个内部对象，并且它拥有一个属性，用来创建内部对象。
    实例.propsDefaults = /* @__PURE__ */ Object.create(null);
    setFullProps（实例，rawProps，道具，属性）；
    对于（instance.propsOptions[0] 中的 const 键）{
      如果（！（输入道具））{
        props[key] = void 0;
      }
    }
    {
      验证Props（rawProps || {}，道具，实例）；
    }
    如果（有状态）{
      实例.props = isSSR ? props : shallowReactive(props);
    } 别的 {
      如果 (!instance.type.props) {
        实例.props = 属性;
      } 别的 {
        实例.props = props;
      }
    }
    实例.属性 = 属性;
  }
  函数 isInHmrContext (实例) {
    while (实例) {
      如果（instance.type.__hmrId）返回true；
      实例 = 实例.父级；
    }
  }
  函数 updateProps（实例，rawProps，rawPrevProps，优化）{
    常量 {
      道具，
      属性，
      vnode: { 补丁标志 }
    } = 实例；
    const rawCurrentProps = toRaw(props);
    const [选项] = 实例.props选项;
    让 hasAttrsChanged = false;
    如果 （
      // 总是在 dev 中强制进行完全差异化
      // - #1942 如果 hmr 与 sfc 组件一起启用
      // - vite#872 sfc 组件使用的非 sfc 组件
      !isInHmrContext(实例) && (优化 || patchFlag > 0) && !(patchFlag & 16)
    ）{
      如果 (补丁标志 & 8) {
        const propsToUpdate = 实例.vnode.dynamicProps;
        对于（让 i = 0; i < propsToUpdate.length; i++）{
          让 key = propsToUpdate[i];
          如果（isEmitListener（instance.emitsOptions，key））{
            继续;
          }
          const 值 = rawProps[key];
          如果（选项）{
            如果 (hasOwn(attrs，key)) {
              如果（值！==属性[键]）{
                属性[键] = 值;
                hasAttrsChanged = true;
              }
            } 别的 {
              const camelizedKey = camelize(key);
              props[camelizedKey] = resolvePropValue(
                选项，
                rawCurrentProps，
                骆驼钥匙，
                价值，
                实例，
                错误的
              （英文）：
            }
          } 别的 {
            如果（值！==属性[键]）{
              属性[键] = 值;
              hasAttrsChanged = true;
            }
          }
        }
      }
    } 别的 {
      如果 (setFullProps(实例，rawProps，props，attrs)) {
        hasAttrsChanged = true;
      }
      让 kebabKey；
      对于（rawCurrentProps 中的 const 键）{
        if (!rawProps || // 对于驼峰式命名法
        !hasOwn(rawProps, key) && // 原始 props 可能以 kebab-case 形式传入
        // 并转换为驼峰式命名 (#955)
        ((kebabKey = hyphenate(key)) === key || !hasOwn(rawProps, kebabKey))) {
          如果（选项）{
            if (rawPrevProps && // 对于 camelCase
            (rawPrevProps[key] !== void 0 || // 用于 kebab-case
            rawPrevProps[kebabKey] !== void 0)) {
              props[key] = resolvePropValue(
                选项，
                rawCurrentProps，
                钥匙，
                无效 0，
                实例，
                真的
              （英文）：
            }
          } 别的 {
            删除 props[key];
          }
        }
      }
      如果 (属性 !== rawCurrentProps) {
        对于（属性中的 const 键）{
          如果 (!rawProps || !hasOwn(rawProps，key) && true) {
            删除属性[key]；
            hasAttrsChanged = true;
          }
        }
      }
    }
    如果 (hasAttrsChanged) {
      触发器（实例。属性，“set”，“”）；
    }
    {
      验证Props（rawProps || {}，道具，实例）；
    }
  }
  函数 setFullProps (实例，rawProps，props，attrs) {
    const [选项，needCastKeys] = 实例.propsOptions;
    让 hasAttrsChanged = false;
    让 rawCastValues；
    如果（rawProps）{
      对于（让 rawProps 中的键）{
        如果（isReservedProp（键））{
          继续;
        }
        const 值 = rawProps[key];
        让 camelKey；
        如果 (选项 && hasOwn(选项， camelKey = camelize(key))) {
          如果（！needCastKeys || ！needCastKeys.includes（camelKey））{
            props[camelKey] = 值;
          } 别的 {
            (rawCastValues || (rawCastValues = {}))[camelKey] = 值;
          }
        } 否则，如果 (!isEmitListener(instance.emitsOptions，key)) {
          如果（！（属性中的键）||值！==属性[键]）{
            属性[键] = 值;
            hasAttrsChanged = true;
          }
        }
      }
    }
    如果 (需要 CastKeys) {
      const rawCurrentProps = toRaw(props);
      const castValues = rawCastValues || EMPTY_OBJ;
      对于（让 i = 0；i < needCastKeys.length；i++）{
        const 键 = needCastKeys[i];
        props[key] = resolvePropValue(
          选项，
          rawCurrentProps，
          钥匙，
          转换值[键]，
          实例，
          ！hasOwn（castValues，键）
        （英文）：
      }
    }
    返回 hasAttrsChanged；
  }
  函数 resolvePropValue (选项， props， key， value， 实例， isAbsent) {
    const opt = 选项[key];
    如果（opt！=空）{
      const hasDefault = hasOwn(opt，“默认”);
      如果 (hasDefault && 值 === void 0) {
        const 默认值 = opt.default;
        如果 (opt.type !== Function && !opt.skipFactory && isFunction(defaultValue)) {
          const { propsDefaults } = 实例；
          如果（输入 propsDefaults）{
            值 = propsDefaults[key];
          } 别的 {
            const 重置 = 设置当前实例 (实例);
            值 = propsDefaults[key] = defaultValue.call(
              无效的，
              道具
            （英文）：
            重置（）;
          }
        } 别的 {
          值 = 默认值；
        }
        如果（实例.ce）{
          实例.ce._setProp（键，值）；
        }
      }
      如果 (opt[0 /* 应该投射 */]) {
        如果 (isAbsent && !hasDefault) {
          值=假；
        } 否则，如果（opt[1 /* shouldCastTrue */] &&（值 === “” || 值 === 连字符（键）））{
          值=真；
        }
      }
    }
    返回值；
  }
  const mixinPropsCache = /* @__PURE__ */ new WeakMap();
  函数 normalizePropsOptions(comp，appContext，asMixin = false) {
    复制代码
    const 缓存 = cache.get(comp);
    如果（缓存）{
      返回缓存；
    }
    const raw = comp.props;
    const 规范化 = {};
    常量需要CastKeys = [];
    让 hasExtends = false;
    如果 (!isFunction(comp)) {
      const extendProps = (raw2) => {
        有扩展 = true;
        const [props，keys] = normalizePropsOptions（raw2，appContext，true）;
        延伸（规范化，道具）；
        如果（键）需要CastKeys.push（...键）；
      };
      如果（！asMixin && appContext.mixins.length）{
        appContext.mixins.forEach（扩展Props）；
      }
      如果 (comp.extends) {
        扩展Props（comp.扩展）；
      }
      如果（comp.mixins）{
        comp.mixins.forEach(extendProps);
      }
    }
    如果 (!raw && !hasExtends) {
      如果 (isObject(comp)) {
        缓存.设置（comp，EMPTY_ARR）；
      }
      返回EMPTY_ARR；
    }
    如果（isArray（原始））{
      对于（让 i = 0; i < raw.length; i++）{
        如果 (!isString(raw[i])) {
          warn$1(`使用数组语法时，props 必须是字符串。`, raw[i]);
        }
        const normalizedKey = camelize（raw[i]）；
        如果 (validatePropName(normalizedKey)) {
          规范化[normalizedKey] = EMPTY_OBJ;
        }
      }
    } 否则，如果（原始）{
      如果 (!isObject(raw)) {
        警告$1（`无效的 props 选项`，原始）；
      }
      对于（原始中的 const 键）{
        const normalizedKey = camelize（key）;
        如果 (validatePropName(normalizedKey)) {
          const opt = raw[key];
          const prop = normalized[normalizedKey] = isArray(opt) || isFunction(opt) ? { 类型：opt } : extend({}, opt);
          const propType = prop.类型;
          让 shouldCast = false;
          让 shouldCastTrue = true;
          如果 (isArray (propType)) {
            对于（让索引 = 0；索引 < propType.length；++index）{
              const 类型 = propType[索引];
              const 类型名称 = isFunction(类型) && 类型.名称​​;
              如果 (typeName === “布尔”) {
                应该投射 = 真;
                休息;
              } 否则，如果 (typeName === “String”) {
                应该CastTrue = false;
              }
            }
          } 别的 {
            shouldCast = isFunction(propType) && propType.name === "Boolean";
          }
          prop[0 /* 应该投射 */] = 应该投射；
          prop[1 /* shouldCastTrue */] = shouldCastTrue;
          如果（shouldCast || hasOwn（prop，“default”））{
            需要CastKeys.推（normalizedKey）；
          }
        }
      }
    }
    const res = [标准化，需要CastKeys];
    如果 (isObject(comp)) {
      缓存.设置（comp，res）；
    }
    返回 res；
  }
  函数validatePropName（key）{
    如果 (key[0] !== "$" && !isReservedProp(key)) {
      返回 true；
    } 别的 {
      warn$1(`无效的 prop 名称：“${key}” 是保留属性。`);
    }
    返回 false；
  }
  函数 getType（ctor）{
    如果 (构造函数 === null) {
      返回“null”；
    }
    如果 (typeof ctor === “函数”) {
      返回 ctor.name ||“”;
    } 否则，如果 (typeof ctor === “object”) {
      const 名称 = 构造函数 && 构造函数.名称;
      返回名称 ||“”;
    }
    返回 ””;
  }
  函数validateProps（rawProps，props，实例）{
    const resolveValues = toRaw(props);
    const 选项 = 实例.props选项[0];
    const camelizePropsKey = Object.keys(rawProps).map((key) => camelize(key));
    对于（选项中的 const 键）{
      让 opt = 选项[key];
      如果（opt==null）继续；
      验证Prop（
        钥匙，
        已解析值[键]，
        选择，
        shallowReadonly（resolvedValues），
        !camelizePropsKey.includes（键）
      （英文）：
    }
  }
  函数validateProp（名称，值，prop，props，isAbsent）{
    const { 类型， 必需， 验证器， skipCheck } = prop;
    如果（必需&&不存在）{
      warn$1('缺少必需的 prop：“' + name + '”');
      返回;
    }
    如果 (值 == null && !required) {
      返回;
    }
    如果 (类型 != null && 类型 !== true && !skipCheck) {
      让 isValid = false;
      const 类型 = isArray(类型) ? 类型 : [类型];
      const 预期类型 = [];
      对于（让 i = 0; i < types.length && !isValid; i++）{
        const { valid，expectedType } = assertType(value，types[i]);
        预期类型.推（预期类型 ||“”）；
        是否有效 = 有效；
      }
      如果（！是有效的）{
        警告$1（getInvalidTypeMessage（名称，值，预期类型））；
        返回;
      }
    }
    如果（验证器&&！验证器（值，道具））{
      warn$1(‘无效 prop：自定义验证器对 prop“’+name+’”的检查失败。’);
    }
  }
  const isSimpleType = /* @__PURE__ */ makeMap(
    “字符串,数字,布尔值,函数,符号,BigInt”
  （英文）：
  函数断言类型（值，类型）{
    让有效；
    const 预期类型 = 获取类型 (类型);
    如果（预期类型 ===“null”）{
      有效 = 值 === null;
    } 否则，如果 (isSimpleType(expectedType)) {
      const t = 值的类型；
      有效 = t === expectedType.toLowerCase();
      如果 (!valid && t === “对象”) {
        有效=类型实例的值；
      }
    } 否则，如果 (expectedType === “Object”) {
      有效 = isObject（值）；
    } 否则，如果 (expectedType === “Array”) {
      有效 = isArray（值）；
    } 别的 {
      有效=类型实例的值；
    }
    返回 {
      有效的，
      预期类型
    };
  }
  函数 getInvalidTypeMessage (名称，值，预期类型) {
    如果 (expectedTypes.length === 0) {
      返回 `prop 类型 [] for prop "${name}" 不会匹配任何内容。您是否想改用类型 Array？`;
    }
    let message = `无效 prop：prop“${name}”的类型检查失败。预期为 ${expectedTypes.map(capitalize).join(" | ")}`;
    const 预期类型 = 预期类型[0];
    const receivedType = toRawType(值);
    const expectedValue = styleValue(值， expectedType);
    const receivedValue = styleValue(值， receivedType);
    如果 (expectedTypes.length === 1 && isExplicable(expectedType) && !isBoolean(expectedType, receivedType)) {
      消息 += ` 其值为 ${expectedValue}`;
    }
    消息 += `, 获取 ${receivedType} `;
    如果 (isExplicable(receivedType)) {
      消息 += `其值为 ${receivedValue}。`;
    }
    返回信息；
  }
  函数 styleValue(值，类型) {
    如果（类型===“字符串”）{
      返回 `"${value}"`;
    } else if (type === "Number") {
      返回 `${Number(value)}`;
    } 别的 {
      返回 `${value}`；
    }
  }
  函数 isExplicable（类型）{
    const 显式类型 = ["字符串", "数字", "布尔值"];
    返回显式类型.some((elem) => type.toLowerCase() === elem);
  }
  函数 isBoolean（...args）{
    返回 args.some((elem) => elem.toLowerCase() === “boolean”);
  }

  const isInternalKey = (key) => key[0] === “_” || key === “$stable”;
  const normalizeSlotValue = (value) => isArray(value) ? value.map(normalizeVNode) : [normalizeVNode(value)];
  const normalizeSlot = (key, rawSlot, ctx) => {
    如果 (rawSlot._n) {
      返回 rawSlot；
    }
    const normalized = withCtx((...args) => {
      如果 (currentInstance && (!ctx || ctx.root === currentInstance.root)) {
        警告$1(
          “在渲染函数之外调用插槽“${key}”：这不会跟踪插槽中使用的依赖项。而是在渲染函数内部调用插槽函数。”
        （英文）：
      }
      返回 normalizeSlotValue(rawSlot(...args));
    复制代码
    标准化._c = false;
    返回标准化；
  };
  const normalizeObjectSlots = (rawSlots, slots, instance) => {
    const ctx = rawSlots._ctx;
    对于（rawSlots 中的 const 键）{
      如果（isInternalKey（key））继续；
      const 值 = rawSlots[key];
      如果 (isFunction(值)) {
        插槽[键] = normalizeSlot(键，值，ctx);
      } 否则，如果（值 != null）{
        {
          警告$1(
            “在槽位“${key}”中遇到非函数值。首选函数槽位以获得更好的性能。”
          （英文）：
        }
        const normalized = normalizeSlotValue(值);
        插槽[key] = () => 标准化；
      }
    }
  };
  const normalizeVNodeSlots = (实例，子项) => {
    如果 (!isKeepAlive(instance.vnode) && true) {
      警告$1(
        “默认槽遇到非函数值。优先使用函数槽以获得更好的性能。”
      （英文）：
    }
    const normalized = normalizeSlotValue(子项);
    实例.slots.default = () => 标准化;
  };
  constassignSlots = (slots, children,optimized) => {
    for（children 中的 const 键）{
      如果（优化||键！==“_”）{
        插槽[键] = 子项[键];
      }
    }
  };
  const initSlots = (实例，子项，优化) => {
    const 插槽 = 实例.插槽 = createInternalObject();
    如果（实例.vnode.shapeFlag & 32）{
      const 类型 = children._;
      如果（类型）{
        分配槽（槽，子槽，优化）；
        如果（优化）{
          def（插槽，“_”，类型，true）；
        }
      } 别的 {
        正常化对象槽（子项，槽位）；
      }
    } 否则，如果 (子项) {
      normalizeVNodeSlots（实例，子节点）；
    }
  };
  const updateSlots = (实例，子项，优化) => {
    const { vnode， 插槽 } = 实例；
    让 needDeletionCheck = true;
    让删除比较目标 = EMPTY_OBJ；
    如果 (vnode.shapeFlag & 32) {
      const 类型 = children._;
      如果（类型）{
        如果（isHmrUpdating）{
          分配槽（槽，子槽，优化）；
          触发器（实例，“set”，“$slots”）；
        } else if (优化 && 类型 === 1) {
          需要删除检查 = false;
        } 别的 {
          分配槽（槽，子槽，优化）；
        }
      } 别的 {
        需要删除检查 = !children.$stable;
        正常化对象槽（子项，槽位）；
      }
      删除比较目标 = 子项；
    } 否则，如果 (子项) {
      normalizeVNodeSlots（实例，子节点）；
      删除比较目标 = { 默认值: 1 };
    }
    如果 (需要删除检查) {
      对于（插槽中的 const 键）{
        如果 (!isInternalKey(key) && deleteComparisonTarget[key] == null) {
          删除插槽[键]；
        }
      }
    }
  };

  让支持；
  让 perf；
  函数 startMeasure（实例，类型）{
    如果（instance.appContext.config.performance && isSupported（））{
      perf.mark(`vue-${type}-${instance.uid}`);
    }
    {
      devtoolsPerfStart（实例，类型，isSupported（）？perf.now（）：Date.now（））;
    }
  }
  函数 endMeasure（实例，类型）{
    如果（instance.appContext.config.performance && isSupported（））{
      const startTag = `vue-${type}-${instance.uid}`;
      const endTag = startTag + `:end`;
      性能.标记（endTag）；
      性能.测量（
        `<${formatComponentName(instance, instance.type)}> ${type}`，
        开始标签，
        结束标签
      （英文）：
      perf.clearMarks（startTag）；
      性能.清除标记（endTag）；
    }
    {
      devtoolsPerfEnd（实例，类型，isSupported（）？perf.now（）：Date.now（））;
    }
  }
  函数 isSupported() {
    如果（支持！== void 0）{
      支持退货；
    }
    如果 (typeof window !== “undefined” && window.performance) {
      支持=真；
      性能 = 窗口.性能；
    } 别的 {
      支持=假；
    }
    支持退货；
  }

  复制代码
  函数 createRenderer（选项）{
    返回 baseCreateRenderer（选项）；
  }
  函数 createHydrationRenderer（选项）{
    返回 baseCreateRenderer（options，createHydrationFunctions）；
  }
  函数 baseCreateRenderer（选项，createHydrationFns）{
    const 目标 = 获取全局变量 ();
    目标.__VUE__ = 真；
    {
      设置DevtoolsHook$1（目标.__VUE_DEVTOOLS_GLOBAL_HOOK__，目标）；
    }
    常量 {
      插入：hostInsert，
      删除：hostRemove，
      patchProp： hostPatchProp，
      创建元素：hostCreateElement，
      创建文本：hostCreateText，
      创建评论： hostCreateComment，
      设置文本：主机设置文本，
      setElementText：主机SetElementText，
      父节点：主机父节点，
      nextSibling： hostNextSibling，
      setScopeId: 主机SetScopeId = NOOP,
      插入静态内容：主机插入静态内容
    } = 选项；
    const patch = (n1, n2, 容器, 锚点 = null, parentComponent = null, parentSuspense = null, 命名空间 = void 0, slotScopeIds = null, 优化 = isHmrUpdating ? false : !!n2.dynamicChildren) => {
      如果 (n1 === n2) {
        返回;
      }
      如果 (n1 && !isSameVNodeType(n1, n2)) {
        锚点 = 获取下一个主机节点（n1）；
        卸载（n1，parentComponent，parentSuspense，true）；
        n1 = 空；
      }
      如果 (n2.patchFlag === -2) {
        优化=错误；
        n2.动态儿童=空;
      }
      const { 类型， ref， shapeFlag } = n2;
      开关（类型）{
        案文：
          处理文本（n1，n2，容器，锚点）；
          休息;
        案例评论：
          processCommentNode(n1， n2， 容器， 锚点)；
          休息;
        案例静态：
          如果 (n1 == 空) {
            mountStaticNode(n2，容器，锚点，命名空间)；
          } 别的 {
            patchStaticNode（n1，n2，容器，命名空间）；
          }
          休息;
        案例片段：
          处理片段（
            n1，
            n2，
            容器，
            锚，
            父组件，
            父级悬念，
            命名空间，
            slotScopeIds，
            优化
          （英文）：
          休息;
        默认：
          如果 (shapeFlag & 1) {
            处理元素（
              n1，
              n2，
              容器，
              锚，
              父组件，
              父级悬念，
              命名空间，
              slotScopeIds，
              优化
            （英文）：
          } 否则，如果 (shapeFlag & 6) {
            处理组件（
              n1，
              n2，
              容器，
              锚，
              父组件，
              父级悬念，
              命名空间，
              slotScopeIds，
              优化
            （英文）：
          } 否则，如果 (shapeFlag & 64) {
            类型.过程（
              n1，
              n2，
              容器，
              锚，
              父组件，
              父级悬念，
              命名空间，
              slotScopeIds，
              优化，
              内部
            （英文）：
          } 否则，如果 (shapeFlag & 128) {
            类型.过程（
              n1，
              n2，
              容器，
              锚，
              父组件，
              父级悬念，
              命名空间，
              slotScopeIds，
              优化，
              内部
            （英文）：
          } 别的 {
            warn$1("无效的 VNode 类型：", type, `(${typeof type})`);
          }
      }
      如果 (ref != null && parentComponent) {
        设置Ref（ref，n1 && n1.ref，parentSuspense，n2 || n1，！n2）；
      }
    };
    const processText = (n1, n2, 容器, 锚点) => {
      如果 (n1 == 空) {
        主机插入（
          n2.el = hostCreateText(n2.children),
          容器，
          锚
        （英文）：
      } 别的 {
        const el = n2.el = n1.el;
        如果 (n2.children !== n1.children) {
          主机设置文本（el，n2.children）；
        }
      }
    };
    const processCommentNode = (n1, n2, 容器, 锚点) => {
      如果 (n1 == 空) {
        主机插入（
          n2.el = hostCreateComment(n2.children || “”),
          容器，
          锚
        （英文）：
      } 别的 {
        n2.el = n1.el;
      }
    };
    const mountStaticNode = (n2, 容器, 锚点, 命名空间) => {
      [n2.el，n2.anchor] = hostInsertStaticContent（
        n2.儿童，
        容器，
        锚，
        命名空间，
        n2.el，
        n2.锚点
      （英文）：
    };
    const patchStaticNode = (n1, n2, 容器, 命名空间) => {
      如果 (n2.children !== n1.children) {
        const anchor = hostNextSibling(n1.anchor);
        删除静态节点（n1）；
        [n2.el，n2.anchor] = hostInsertStaticContent（
          n2.儿童，
          容器，
          锚，
          命名空间
        （英文）：
      } 别的 {
        n2.el = n1.el;
        n2.锚点 = n1.锚点；
      }
    };
    const moveStaticNode = ({ el, anchor }, container, nextSibling) => {
      让下一个；
      当 (el && el !== 锚点) {
        下一个 = hostNextSibling(el);
        hostInsert（el， 容器， nextSibling ）；
        el=下一个；
      }
      hostInsert（锚点， 容器， nextSibling ）；
    };
    const removeStaticNode = ({ el, anchor }) => {
      让下一个；
      当 (el && el !== 锚点) {
        下一个 = hostNextSibling(el);
        主机删除（el）；
        el=下一个；
      }
      主机删除（锚点）；
    };
    const processElement = (n1, n2, 容器, 锚点, parentComponent, parentSuspense, 命名空间, slotScopeIds, 优化) => {
      如果 (n2.type === “svg”) {
        命名空间 = “svg”;
      } 否则，如果 (n2.type === “math”) {
        命名空间 = “mathml”;
      }
      如果 (n1 == 空) {
        安装元素（
          n2，
          容器，
          锚，
          父组件，
          父级悬念，
          命名空间，
          slotScopeIds，
          优化
        （英文）：
      } 别的 {
        补丁元素（
          n1，
          n2，
          父组件，
          父级悬念，
          命名空间，
          slotScopeIds，
          优化
        （英文）：
      }
    };
    const mountElement = (vnode, 容器, 锚点, parentComponent, parentSuspense, 命名空间, slotScopeIds, 优化) => {
      让 el；
      让 vnodeHook；
      const { props，shapeFlag，transition，dirs } = vnode;
      el = vnode.el = hostCreateElement（
        vnode.类型，
        命名空间，
        道具 && 道具.是，
        道具
      （英文）：
      如果 (shapeFlag & 8) {
        hostSetElementText(el, vnode.children);
      } 否则，如果 (shapeFlag & 16) {
        mountChildren（
          vnode.children，
          埃尔，
          无效的，
          父组件，
          父级悬念，
          resolveChildrenNamespace（vnode，namespace），
          slotScopeIds，
          优化
        （英文）：
      }
      如果（目录）{
        调用DirectiveHook（vnode，null，parentComponent，“创建”）；
      }
      setScopeId(el, vnode, vnode.scopeId, slotScopeIds, ParentComponent);
      如果（道具）{
        对于（props中的const键）{
          如果 (key !== “value” && !isReservedProp(key)) {
            hostPatchProp（el，key，null，props [key]，namespace，parentComponent）;
          }
        }
        如果 (props 中的“值”) {
          hostPatchProp（el，“值”，null，props.value，命名空间）；
        }
        如果（vnodeHook = props.onVnodeBeforeMount）{
          调用VNodeHook（vnodeHook，parentComponent，vnode）；
        }
      }
      {
        def（el，“__vnode”，vnode，true）；
        def（el，“__vueParentComponent”，parentComponent，true）;
      }
      如果（目录）{
        调用DirectiveHook（vnode，null，parentComponent，“beforeMount”）；
      }
      声明一个转换函数来让其返回一个转换结果。
      如果 (需要CallTransitionHooks) {
        转换.beforeEnter（el）；
      }
      hostInsert（el，容器，锚点）；
      如果（（vnodeHook = props && props.onVnodeMounted）|| needCallTransitionHooks || dirs）{
        队列后渲染效果（）=> {
          vnodeHook && invokeVNodeHook(vnodeHook， parentComponent， vnode);
          需要CallTransitionHooks && transition.enter(el);
          目录&&invokeDirectiveHook(vnode，null，parentComponent，“mounted”);
        }，父Suspense);
      }
    };
    const setScopeId =（el，vnode，scopeId，slotScopeIds，parentComponent）=> {
      如果 (scopeId) {
        主机设置ScopeId（el，scopeId）；
      }
      如果 (slotScopeIds) {
        对于（让 i = 0；i < slotScopeIds.length；i++）{
          hostSetScopeId(el, slotScopeIds[i]);
        }
      }
      如果（父组件）{
        让子树 = 父组件.子树；
        如果 (subTree.patchFlag > 0 && subTree.patchFlag & 2048) {
          子树 = 过滤器SingleRoot（子树.children）|| 子树；
        }
        如果 (vnode === subTree || isSuspense(subTree.type) && (subTree.ssContent === vnode || subTree.ssFallback === vnode)) {
          const parentVNode = parentComponent.vnode;
          设置ScopeId（
            埃尔，
            parentVNode，
            parentVNode.scopeId，
            parentVNode.slotScopeIds，
            父组件。
          （英文）：
        }
      }
    };
    const mountChildren = (children, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds,optimized, start = 0) => {
      对于（让 i = 开始；i < children.length；i++）{
        const child = children[i] = 优化？ cloneIfMounted(children[i]) : normalizeVNode(children[i]);
        修补（
          无效的，
          孩子，
          容器，
          锚，
          父组件，
          父级悬念，
          命名空间，
          slotScopeIds，
          优化
        （英文）：
      }
    };
    const patchElement = (n1, n2, parentComponent, parentSuspense, namespace, slotScopeIds,optimized) => {
      const el = n2.el = n1.el;
      {
        el.__vnode = n2;
      }
      让 { patchFlag， dynamicChildren， dirs } = n2；
      补丁标志 |= n1.补丁标志 & 16;
      const oldProps = n1.props || EMPTY_OBJ;
      const newProps = n2.props || EMPTY_OBJ;
      让 vnodeHook；
      父组件 && toggleRecurse（父组件，false）；
      如果（vnodeHook = newProps.onVnodeBeforeUpdate）{
        调用VNodeHook（vnodeHook，parentComponent，n2，n1）；
      }
      如果（目录）{
        调用DirectiveHook(n2， n1， parentComponent，“beforeUpdate”);
      }
      父组件 && toggleRecurse(父组件， true);
      如果（isHmrUpdating）{
        补丁标志 = 0;
        优化=错误；
        动态儿童=空；
      }
      if (oldProps.innerHTML && newProps.innerHTML == null || oldProps.textContent && newProps.textContent == null) {
        主机设置元素文本（el，“”）；
      }
      如果（动态儿童）{
        patchBlockChildren（
          n1.动态儿童，
          dynamicChildren，
          埃尔，
          父组件，
          父级悬念，
          resolveChildrenNamespace(n2，命名空间)，
          slotScopeIds
        （英文）：
        {
          遍历静态子代（n1，n2）；
        }
      } 否则，如果（！优化）{
        patchChildren（
          n1，
          n2，
          埃尔，
          无效的，
          父组件，
          父级悬念，
          resolveChildrenNamespace(n2，命名空间)，
          slotScopeIds，
          错误的
        （英文）：
      }
      如果 (补丁标志 > 0) {
        如果 (补丁标志 & 16) {
          patchProps（el，oldProps，newProps，parentComponent，命名空间）；
        } 别的 {
          如果 (补丁标志 & 2) {
            如果 (oldProps.class !== newProps.class) {
              hostPatchProp（el， “class”，null，newProps.class，namespace）；
            }
          }
          如果 (补丁标志 & 4) {
            hostPatchProp（el， “style”，oldProps.style，newProps.style，命名空间）；
          }
          如果 (补丁标志 & 8) {
            const propsToUpdate = n2.dynamicProps;
            对于（让 i = 0; i < propsToUpdate.length; i++）{
              const 键 = propsToUpdate[i];
              const prev = oldProps[key];
              const next = newProps[key];
              如果（下一个！==上一个||键===“值”）{
                hostPatchProp（el，key，prev，next，namespace，parentComponent）;
              }
            }
          }
        }
        如果 (补丁标志 & 1) {
          如果 (n1.children !== n2.children) {
            hostSetElementText(el, n2.children);
          }
        }
      } 否则，如果 (!optimized && dynamicChildren == null) {
        patchProps（el，oldProps，newProps，parentComponent，命名空间）；
      }
      if ((vnodeHook = newProps.onVnodeUpdated) || dirs) {
        队列后渲染效果（）=> {
          vnodeHook && invokeVNodeHook(vnodeHook， parentComponent， n2， n1);
          dirs &&invokeDirectiveHook(n2， n1，parentComponent，“已更新”);
        }，父Suspense);
      }
    };
    const patchBlockChildren = (oldChildren, newChildren, fallbackContainer, parentComponent, parentSuspense, namespace, slotScopeIds) => {
      对于（让 i = 0; i < newChildren.length; i++）{
        const oldVNode = oldChildren[i];
        const newVNode = newChildren[i];
        const 容器 = （
          // oldVNode 可能是 Suspense 中错误的异步 setup() 组件
          // 将不会有一个已安装的元素
          oldVNode.el && // - 对于 Fragment，我们需要提供实际的父级
          // Fragment 本身，因此它可以移动其子项。
          (oldVNode.type === Fragment || // - 如果是不同的节点，则需要进行替换
          // 这也需要正确的父容器
          !isSameVNodeType(oldVNode, newVNode) || // - 对于组件来说，它可以包含任何东西。
          oldVNode.shapeFlag & (6 | 64)) ？主机父节点（oldVNode.el）：（
            // 在其他情况下，父容器实际上没有被使用，所以我们
            // 只需在此处传递块元素，即可避免 DOM parentNode 调用。
            fallback容器
          ）
        （英文）：
        修补（
          旧VNode，
          新的VNode，
          容器，
          无效的，
          父组件，
          父级悬念，
          命名空间，
          slotScopeIds，
          真的
        （英文）：
      }
    };
    const patchProps = (el, oldProps, newProps, parentComponent, namespace) => {
      如果 (旧Props !== 新Props) {
        如果 (oldProps !== EMPTY_OBJ) {
          对于（oldProps 中的 const 键）{
            如果 (!isReservedProp(key) && !(newProps 中的 key)) {
              主机补丁属性(
                埃尔，
                钥匙，
                oldProps[key]，
                无效的，
                命名空间，
                父组件
              （英文）：
            }
          }
        }
        对于（newProps 中的 const 键）{
          如果（isReservedProp（key））继续；
          const next = newProps[key];
          const prev = oldProps[key];
          如果（下一个！==上一个&&键！==“值”）{
            hostPatchProp（el，key，prev，next，namespace，parentComponent）;
          }
        }
        如果 (newProps 中的“值”) {
          hostPatchProp（el， “值”，oldProps.value，newProps.value，命名空间）；
        }
      }
    };
    const processFragment = (n1, n2, 容器, 锚点, parentComponent, parentSuspense, 命名空间, slotScopeIds, 优化) => {
      const fragmentStartAnchor = n2.el = n1 ? n1.el : hostCreateText(“”);
      const fragmentEndAnchor = n2.anchor = n1 ? n1.anchor : hostCreateText(“”);
      让 { patchFlag， dynamicChildren， slotScopeIds： fragmentSlotScopeIds } = n2；
      如果 （
        // #5523 dev 根片段可以继承指令
        isHmrUpdating || patchFlag & 2048
      ）{
        补丁标志 = 0;
        优化=错误；
        动态儿童=空；
      }
      如果 (fragmentSlotScopeIds) {
        片段SlotScopeIds
      }
      如果 (n1 == 空) {
        hostInsert（fragmentStartAnchor，容器，锚点）；
        hostInsert（fragmentEndAnchor，容器，锚点）；
        mountChildren（
          // #10007
          // 像 `<></>` 这样的片段将被编译成
          // 没有子项的片段。
          // 在这种情况下回退到空数组
          n2.孩子 || [],
          容器，
          fragmentEndAnchor，
          父组件，
          父级悬念，
          命名空间，
          slotScopeIds，
          优化
        （英文）：
      } 别的 {
        if (patchFlag > 0 && patchFlag & 64 && dynamicChildren && // #2715 前一个片段可能因此被 BAILed
        // renderSlot() 没有有效的子项
        n1.动态儿童）{
          patchBlockChildren（
            n1.动态儿童，
            dynamicChildren，
            容器，
            父组件，
            父级悬念，
            命名空间，
            slotScopeIds
          （英文）：
          {
            遍历静态子代（n1，n2）；
          }
        } 别的 {
          patchChildren（
            n1，
            n2，
            容器，
            fragmentEndAnchor，
            父组件，
            父级悬念，
            命名空间，
            slotScopeIds，
            优化
          （英文）：
        }
      }
    };
    const processComponent = (n1, n2, 容器, 锚点, parentComponent, parentSuspense, 命名空间, slotScopeIds, 优化) => {
      n2.槽范围ID = 槽范围ID;
      如果 (n1 == 空) {
        如果 (n2.shapeFlag & 512) {
          父组件.ctx.activate(
            n2，
            容器，
            锚，
            命名空间，
            优化
          （英文）：
        } 别的 {
          安装组件（
            n2，
            容器，
            锚，
            父组件，
            父级悬念，
            命名空间，
            优化
          （英文）：
        }
      } 别的 {
        更新组件（n1，n2，优化）；
      }
    };
    const mountComponent = (initialVNode, container, anchor, parentComponent, parentSuspense, namespace,optimized) => {
      const 实例 = （initialVNode.component = createComponentInstance（
        初始VNode，
        父组件，
        父级悬念
      ））；
      如果 (实例.类型.__hmrId) {
        注册HMR（实例）；
      }
      {
        PushWarningContext(initialVNode);
        开始测量（实例，`mount`）；
      }
      如果 (isKeepAlive(initialVNode)) {
        实例.ctx.渲染器 = 内部；
      }
      {
        {
          开始测量（实例，`init`）；
        }
        设置组件（实例，false，优化）；
        {
          endMeasure（实例，`init`）；
        }
      }
      如果（实例.asyncDep）{
        如果（isHmrUpdating）initialVNode.el = null;
        parentSuspense && parentSuspense.registerDep(实例，setupRenderEffect，优化);
        如果 (!initialVNode.el) {
          const 占位符 = 实例.subTree = createVNode(评论);
          processCommentNode（null，占位符，容器，锚点）；
        }
      } 别的 {
        设置渲染效果（
          实例，
          初始VNode，
          容器，
          锚，
          父级悬念，
          命名空间，
          优化
        （英文）：
      }
      {
        弹出警告上下文()；
        endMeasure（实例，`mount`）；
      }
    };
    const updateComponent = (n1, n2, 优化) => {
      const 实例 = n2.组件 = n1.组件;
      如果（shouldUpdateComponent（n1，n2，优化））{
        如果 (instance.asyncDep && !instance.asyncResolved) {
          {
            推送警告上下文（n2）；
          }
          updateComponentPreRender（实例，n2，优化）；
          {
            弹出警告上下文()；
          }
          返回;
        } 别的 {
          实例.next = n2;
          实例.更新（）；
        }
      } 别的 {
        n2.el = n1.el;
        实例.vnode = n2;
      }
    };
    const setupRenderEffect = (instance, initialVNode,container,anchor,parentSuspense,namespace,optimized) => {
      const componentUpdateFn = () => {
        如果（！实例.isMounted）{
          让 vnodeHook；
          const { el， props } = initialVNode;
          const { bm， m， 父级， 根， 类型 } = 实例；
          const isAsyncWrapperVNode = isAsyncWrapper(initialVNode);
          切换Recurse（实例，false）；
          如果（BM）{
            调用ArrayFns（bm）；
          }
          如果（！isAsyncWrapperVNode &&（vnodeHook = props && props.onVnodeBeforeMount））{
            调用VNodeHook（vnodeHook， 父节点， 初始VNode）；
          }
          toggleRecurse（实例，true）；
          如果 (el && hydrateNode) {
            const hydrateSubTree = () => {
              {
                开始测量（实例，`渲染`）；
              }
              实例.subTree = renderComponentRoot(实例);
              {
                endMeasure（实例，`渲染`）；
              }
              {
                开始测量（实例，`水合物`）；
              }
              水合节点（
                埃尔，
                实例.子树，
                实例，
                父级悬念，
                无效的
              （英文）：
              {
                endMeasure（实例，`水合物`）；
              }
            };
            如果（isAsyncWrapperVNode && 类型.__asyncHydrate）{
              类型.__asyncHydrate（
                埃尔，
                实例，
                水合子树
              （英文）：
            } 别的 {
              水合子树()；
            }
          } 别的 {
            如果（root.ce）{
              root.ce._injectChildStyle（类型）；
            }
            {
              开始测量（实例，`渲染`）；
            }
            const subTree = 实例.subTree = renderComponentRoot(实例);
            {
              endMeasure（实例，`渲染`）；
            }
            {
              开始测量（实例，`补丁`）；
            }
            修补（
              无效的，
              子树，
              容器，
              锚，
              实例，
              父级悬念，
              命名空间
            （英文）：
            {
              endMeasure（实例，`补丁`）；
            }
            初始VNode.el = 子树.el;
          }
          如果（米）{
            队列后渲染效果（m，parentSuspense）；
          }
          如果（！isAsyncWrapperVNode &&（vnodeHook = props && props.onVnodeMounted））{
            const scopedInitialVNode = initialVNode;
            队列后渲染效果（
              （）=>invokeVNodeHook（vnodeHook，parent，scopedInitialVNode），
              父级悬念
            （英文）：
          }
          如果 (initialVNode.shapeFlag & 256 || 父母 && isAsyncWrapper (父母.vnode) && 父母.vnode.shapeFlag & 256) {
            实例.a && 队列后渲染效果（实例.a，parentSuspense）；
          }
          实例.isMounted = true;
          {
            devtoolsComponentAdded（实例）；
          }
          初始VNode = 容器 = 锚点 = 空；
        } 别的 {
          让 { next, bu, u, parent, vnode } = instance;
          {
            const nonHydratedAsyncRoot =locateNonHydratedAsyncRoot(实例);
            如果 (nonHydratedAsyncRoot) {
              如果（下一个）{
                下一个.el = vnode.el;
                updateComponentPreRender（实例，下一步，优化）；
              }
              nonHydratedAsyncRoot.asyncDep.then(() => {
                如果（！实例.isUnmounted）{
                  组件更新函数（）；
                }
              });
              返回;
            }
          }
          让 originNext = next;
          让 vnodeHook；
          {
            PushWarningContext(下一个||实例.vnode);
          }
          切换Recurse（实例，false）；
          如果（下一个）{
            下一个.el = vnode.el;
            updateComponentPreRender（实例，下一步，优化）；
          } 别的 {
            下一个=vnode；
          }
          如果（布）{
            调用ArrayFns（bu）；
          }
          如果（vnodeHook = next.props && next.props.onVnodeBeforeUpdate）{
            调用VNodeHook（vnodeHook，父节点，下一个，vnode）；
          }
          toggleRecurse（实例，true）；
          {
            开始测量（实例，`渲染`）；
          }
          const nextTree = renderComponentRoot(实例);
          {
            endMeasure（实例，`渲染`）；
          }
          const prevTree = 实例.subTree;
          实例.子树 = 下一树;
          {
            开始测量（实例，`补丁`）；
          }
          修补（
            上一棵树，
            下一棵树，
            // 如果处于传送状态，父级可能已经改变
            hostParentNode（prevTree.el），
            // 如果锚点位于片段中，则可能已发生改变
            获取下一个主机节点（prevTree），
            实例，
            父级悬念，
            命名空间
          （英文）：
          {
            endMeasure（实例，`补丁`）；
          }
          下一个.el = 下一个树.el;
          如果 (originNext === null) {
            更新HOCHostEl（实例，nextTree.el）；
          }
          如果（你）{
            队列后渲染效果（u，parentSuspense）；
          }
          如果（vnodeHook = next.props && next.props.onVnodeUpdated）{
            队列后渲染效果（
              () =>invokeVNodeHook(vnodeHook，parent，next，vnode)，
              父级悬念
            （英文）：
          }
          {
            devtoolsComponentUpdated（实例）；
          }
          {
            弹出警告上下文()；
          }
        }
      };
      实例.范围.on()；
      const 效果 = 实例.效果 = 新 ReactiveEffect (componentUpdateFn);
      实例.范围.关闭（）；
      const 更新 = 实例.更新 = 效果.运行.绑定(效果);
      const job = 实例.job = effect.runIfDirty.bind(effect);
      job.i = 实例；
      作业.id = 实例.uid;
      effect.scheduler = () => 队列作业(作业);
      toggleRecurse（实例，true）；
      {
        效果.onTrack = 实例.rtc ？（e）=>invokeArrayFns（实例.rtc，e）：void 0；
        effect.onTrigger = instance.rtg ? (e) => invokeArrayFns(instance.rtg, e) : void 0;
      }
      更新（）;
    };
    const updateComponentPreRender = (实例，nextVNode，优化) => {
      nextVNode.组件 = 实例；
      const prevProps = 实例.vnode.props;
      实例.vnode = nextVNode;
      实例.next = null;
      updateProps（实例，nextVNode.props，prevProps，优化）；
      updateSlots（实例，nextVNode.children，优化）；
      暂停跟踪（）；
      flushPreFlushCbs（实例）；
      重置跟踪（）；
    };
    const patchChildren = (n1, n2, 容器, 锚点, parentComponent, parentSuspense, 命名空间, slotScopeIds, 优化 = false) => {
      const c1 = n1 && n1.children;
      const prevShapeFlag = n1 ? n1.shapeFlag : 0;
      const c2 = n2.children;
      const { patchFlag，shapeFlag } = n2；
      如果 (补丁标志 > 0) {
        如果 (补丁标志 & 128) {
          patchKeyedChildren（
            c1，
            c2，
            容器，
            锚，
            父组件，
            父级悬念，
            命名空间，
            slotScopeIds，
            优化
          （英文）：
          返回;
        }否则，如果（patchFlag & 256）{
          patchUnkeyedChildren（
            c1，
            c2，
            容器，
            锚，
            父组件，
            父级悬念，
            命名空间，
            slotScopeIds，
            优化
          （英文）：
          返回;
        }
      }
      如果 (shapeFlag & 8) {
        如果 (prevShapeFlag & 16) {
          卸载子组件（c1，parentComponent，parentSuspense）；
        }
        如果 (c2 !== c1) {
          hostSetElementText（容器，c2）；
        }
      } 别的 {
        如果 (prevShapeFlag & 16) {
          如果 (shapeFlag & 16) {
            patchKeyedChildren（
              c1，
              c2，
              容器，
              锚，
              父组件，
              父级悬念，
              命名空间，
              slotScopeIds，
              优化
            （英文）：
          } 别的 {
            卸载Children（c1，parentComponent，parentSuspense，true）；
          }
        } 别的 {
          如果 (prevShapeFlag & 8) {
            hostSetElementText（容器，“”）；
          }
          如果 (shapeFlag & 16) {
            mountChildren（
              c2，
              容器，
              锚，
              父组件，
              父级悬念，
              命名空间，
              slotScopeIds，
              优化
            （英文）：
          }
        }
      }
    };
    const patchUnkeyedChildren = (c1, c2, 容器, 锚点, parentComponent, parentSuspense, 命名空间, slotScopeIds, 优化) => {
      c1 = c1 || 空ARR；
      c2 = c2 || 空_ARR；
      const oldLength = c1.长度;
      const newLength = c2.长度;
      const commonLength = Math.min(旧长度，新长度);
      让我；
      对于（i = 0；i < commonLength；i++）{
        const nextChild = c2[i] = 优化？ cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
        修补（
          c1[i]，
          下一个孩子，
          容器，
          无效的，
          父组件，
          父级悬念，
          命名空间，
          slotScopeIds，
          优化
        （英文）：
      }
      如果 (旧长度 > 新长度) {
        卸载子代（
          c1，
          父组件，
          父级悬念，
          真的，
          错误的，
          共同长度
        （英文）：
      } 别的 {
        mountChildren（
          c2，
          容器，
          锚，
          父组件，
          父级悬念，
          命名空间，
          slotScopeIds，
          优化，
          共同长度
        （英文）：
      }
    };
    const patchKeyedChildren = (c1, c2, 容器, parentAnchor, parentComponent, parentSuspense, 命名空间, slotScopeIds, 优化) => {
      让 i = 0;
      const l2 = c2.长度;
      让 e1 = c1.length - 1;
      让 e2 = l2 - 1；
      while (i <= e1 && i <= e2) {
        const n1 = c1[i];
        const n2 = c2[i] = 优化？ cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
        如果 (isSameVNodeType(n1，n2)) {
          修补（
            n1，
            n2，
            容器，
            无效的，
            父组件，
            父级悬念，
            命名空间，
            slotScopeIds，
            优化
          （英文）：
        } 别的 {
          休息;
        }
        我++；
      }
      while (i <= e1 && i <= e2) {
        const n1 = c1[e1];
        const n2 = c2[e2] = 优化？ cloneIfMounted(c2[e2]) : normalizeVNode(c2[e2]);
        如果 (isSameVNodeType(n1，n2)) {
          修补（
            n1，
            n2，
            容器，
            无效的，
            父组件，
            父级悬念，
            命名空间，
            slotScopeIds，
            优化
          （英文）：
        } 别的 {
          休息;
        }
        e1--；
        e2--；
      }
      如果 (i > e1) {
        如果 (i <= e2) {
          const nextPos = e2 + 1;
          const anchor = nextPos < l2 ? c2[nextPos].el: parentAnchor;
          当 (i <= e2) {
            修补（
              无效的，
              c2[i] = 优化？ cloneIfMounted(c2[i]) : normalizeVNode(c2[i])，
              容器，
              锚，
              父组件，
              父级悬念，
              命名空间，
              slotScopeIds，
              优化
            （英文）：
            我++；
          }
        }
      } 否则，如果 (i > e2) {
        当 (i <= e1) {
          卸载（c1[i]，parentComponent，parentSuspense，true）；
          我++；
        }
      } 别的 {
        const s1 = i;
        const s2 = i;
        const keyToNewIndexMap = /* @__PURE__ */ new Map();
        对于（i = s2；i <= e2；i++）{
          const nextChild = c2[i] = 优化？ cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
          如果（nextChild.key != null）{
            如果 (keyToNewIndexMap.has(nextChild.key)) {
              警告$1(
                `更新期间发现重复的键：`，
                JSON.stringify（nextChild.key），
                `确保密钥是唯一的。`
              （英文）：
            }
            keyToNewIndexMap.设置（nextChild.key，i）；
          }
        }
        让 j；
        让 patched = 0;
        const toBePatched = e2 - s2 + 1;
        让移动 = false;
        让 maxNewIndexSoFar = 0;
        const newIndexToOldIndexMap = new Array(toBePatched);
        对于 (i = 0; i < toBePatched; i++) newIndexToOldIndexMap[i] = 0;
        对于（i = s1；i <= e1；i++）{
          const prevChild = c1[i];
          如果 (已修补 >= 待修补) {
            卸载（prevChild，parentComponent，parentSuspense，true）；
            继续;
          }
          让新索引；
          如果 (prevChild.key != null) {
            newIndex = keyToNewIndexMap.get(prevChild.key);
          } 别的 {
            对于 (j = s2; j <= e2; j++) {
              如果 (newIndexToOldIndexMap[j - s2] === 0 && isSameVNodeType(prevChild，c2[j])) {
                新索引 = j;
                休息;
              }
            }
          }
          如果 (newIndex === void 0) {
            卸载（prevChild，parentComponent，parentSuspense，true）；
          } 别的 {
            newIndexToOldIndexMap[newIndex - s2] = i + 1;
            如果 (newIndex >= maxNewIndexSoFar) {
              最大新索引距离 = 新索引；
            } 别的 {
              移动=真；
            }
            修补（
              前一个孩子，
              c2[新索引]，
              容器，
              无效的，
              父组件，
              父级悬念，
              命名空间，
              slotScopeIds，
              优化
            （英文）：
            修补++；
          }
        }
        const increasingNewIndexSequence = 移动？getSequence（newIndexToOldIndexMap）：EMPTY_ARR；
        j = increasingNewIndexSequence.length - 1;
        对于（i = toBePatched - 1; i >= 0; i--）{
          const nextIndex = s2 + i;
          const nextChild = c2[nextIndex];
          const anchor = nextIndex + 1 < l2 ? c2[nextIndex + 1].el: parentAnchor;
          如果 (newIndexToOldIndexMap[i] === 0) {
            修补（
              无效的，
              下一个孩子，
              容器，
              锚，
              父组件，
              父级悬念，
              命名空间，
              slotScopeIds，
              优化
            （英文）：
          } else if（移动）{
            如果 (j < 0 || i !== increasingNewIndexSequence[j]) {
              移动（nextChild，容器，锚点，2）；
            } 别的 {
              卞--；
            }
          }
        }
      }
    };
    const move = (vnode, container, anchor, moveType, parentSuspense = null) => {
      const { el， 类型， 转换， 子级， shapeFlag } = vnode;
      如果 (shapeFlag & 6) {
        移动（vnode.component.subTree，容器，锚点，移动类型）；
        返回;
      }
      如果 (shapeFlag & 128) {
        vnode.suspense.move（容器，锚点，moveType）；
        返回;
      }
      如果 (shapeFlag & 64) {
        类型.move（vnode，容器，锚点，内部）；
        返回;
      }
      如果（类型===片段）{
        hostInsert（el，容器，锚点）；
        对于（让 i = 0; i < children.length; i++）{
          移动（儿童[i]，容器，锚点，移动类型）；
        }
        hostInsert（vnode.anchor，容器，锚点）；
        返回;
      }
      如果（类型===静态）{
        移动静态节点（vnode，容器，锚点）；
        返回;
      }
      const needTransition2 = moveType !== 2 && shapeFlag & 1 && transition;
      如果 (需要转换2) {
        如果 (moveType === 0) {
          转换.beforeEnter（el）；
          hostInsert（el，容器，锚点）；
          队列后渲染效果（（）=> transition.enter（el），parentSuspense）；
        } 别的 {
          const { 离开， 延迟离开， 离开后 } = 转换；
          const remove2 = () => hostInsert(el, container, anchor);
          const performLeave = () => {
            离开（el，（）=> {
              删除2（）；
              离开之后 && 离开之后();
            });
          };
          如果（延迟离开）{
            延迟离开（el，remove2，performLeave）；
          } 别的 {
            执行离开()；
          }
        }
      } 别的 {
        hostInsert（el，容器，锚点）；
      }
    };
    const unmount = (vnode, parentComponent, parentSuspense, doRemove = false, optimizer = false) => {
      常量 {
        类型，
        道具，
        参考，
        孩子们，
        dynamicChildren，
        形状标志，
        补丁标志，
        目录，
        缓存索引
      } = 虚拟节点；
      如果 (patchFlag === -2) {
        优化=错误；
      }
      如果 (ref != null) {
        设置Ref（ref，null，parentSuspense，vnode，true）；
      }
      如果 (cacheIndex != null) {
        父组件.renderCache[cacheIndex] = void 0;
      }
      如果 (shapeFlag & 256) {
        父组件.ctx.停用（vnode）；
        返回;
      }
      const shouldInvokeDirs = shapeFlag & 1 && dirs;
      复制代码
      让 vnodeHook；
      如果（shouldInvokeVnodeHook &&（vnodeHook = props && props.onVnodeBeforeUnmount））{
        调用VNodeHook（vnodeHook，parentComponent，vnode）；
      }
      如果 (shapeFlag & 6) {
        卸载组件（vnode.component，parentSuspense，doRemove）；
      } 别的 {
        如果 (shapeFlag & 128) {
          vnode.suspense.unmount（parentSuspense，doRemove）；
          返回;
        }
        如果（shouldInvokeDirs）{
          invDirectiveHook（vnode，null，parentComponent，“beforeUnmount”）；
        }
        如果 (shapeFlag & 64) {
          vnode.类型.删除（
            虚拟节点，
            父组件，
            父级悬念，
            内部，
            删除
          （英文）：
        } 否则，如果 (dynamicChildren && // #5154
        // 当 v-once 在块内使用时，setBlockTracking(-1) 标记
        // 父块具有 hasOnce: true
        // 这样它在卸载时就不会采用快速路径 - 否则
        // 嵌套在 v-once 中的组件永远不会被卸载。
        !dynamicChildren.hasOnce && // #1153: 对于非稳定（v-for）片段，不应采用快速路径
        (类型 !== 片段 || patchFlag > 0 && patchFlag & 64)) {
          卸载子代（
            dynamicChildren，
            父组件，
            父级悬念，
            错误的，
            真的
          （英文）：
        } 否则，如果 (类型 === 片段 && patchFlag & (128 | 256) || !优化 && shapeFlag & 16) {
          卸载子组件（子组件，父组件，父组件悬念）；
        }
        如果（删除）{
          删除（vnode）；
        }
      }
      如果（shouldInvokeVnodeHook &&（vnodeHook = props && props.onVnodeUnmounted）|| shouldInvokeDirs）{
        队列后渲染效果（）=> {
          vnodeHook && invokeVNodeHook(vnodeHook， parentComponent， vnode);
          应该InvokeDirs &&invokeDirectiveHook(vnode，null，parentComponent，“未安装”);
        }，父Suspense);
      }
    };
    const 删除 = （vnode）=> {
      const { 类型， el， 锚点， 转换 } = vnode;
      如果（类型===片段）{
        如果 (vnode.patchFlag > 0 && vnode.patchFlag & 2048 && 转换 && !transition.persisted) {
          vnode.children.forEach((child) => {
            如果（child.type === 评论）{
              主机删除（child.el）；
            } 别的 {
              删除（子项）；
            }
          });
        } 别的 {
          移除片段（el，anchor）；
        }
        返回;
      }
      如果（类型===静态）{
        删除静态节点（vnode）；
        返回;
      }
      const performRemove = () => {
        主机删除（el）；
        如果（转换 && ！转换.持久化 && 转换.离开后）{
          过渡.离开后()；
        }
      };
      如果（vnode.shapeFlag & 1 && 转换 && ！transition.persisted）{
        const { 离开，延迟离开 } = 转换；
        const performLeave = () => 离开（el， performRemove）；
        如果（延迟离开）{
          延迟离开（vnode.el， performRemove， performLeave）；
        } 别的 {
          执行离开()；
        }
      } 别的 {
        执行删除（）；
      }
    };
    const removeFragment = (cur，end) => {
      让下一个；
      当 (cur !== 结束) {
        下一个 = hostNextSibling(cur);
        主机删除（cur）；
        当前=下一个；
      }
      主机删除（结束）；
    };
    const unmountComponent = (instance, parentSuspense, doRemove) => {
      如果 (实例.类型.__hmrId) {
        取消注册HMR（实例）；
      }
      const { bum, scope, job, subTree, um, m, a } = instance;
      使挂载无效（m）；
      使挂载无效（a）；
      如果（屁股）{
        调用ArrayFns（bum）；
      }
      范围.停止（）；
      如果（工作）{
        作业.标志 |= 8;
        卸载（子树，实例，parentSuspense，doRemove）;
      }
      如果（嗯）{
        queuePostRenderEffect(嗯，parentSuspense);
      }
      队列后渲染效果（）=> {
        实例.isUnmounted = true;
      }，父Suspense);
      如果 (parentSuspense && parentSuspense.pendingBranch && !parentSuspense.isUnmounted && instance.asyncDep && !instance.asyncResolved && instance.suspenseId === parentSuspense.pendingId) {
        父Suspense.deps--;
        if (parentSuspense.deps === 0) {
          父Suspense.resolve()；
        }
      }
      {
        devtoolsComponentRemoved（实例）；
      }
    };
    const unmountChildren = (children, parentComponent, parentSuspense, doRemove = false,optimized = false, start = 0) => {
      对于（让 i = 开始；i < children.length；i++）{
        卸载（children[i]，parentComponent，parentSuspense，doRemove，优化）；
      }
    };
    const getNextHostNode = (vnode) => {
      如果 (vnode.shapeFlag & 6) {
        返回 getNextHostNode(vnode.component.subTree);
      }
      如果（vnode.shapeFlag & 128）{
        返回 vnode.suspense.next();
      }
      const el = hostNextSibling(vnode.anchor || vnode.el);
      const teleportEnd = el && el[TeleportEndKey];
      返回 teleportEnd ？ hostNextSibling (teleportEnd) : el;
    };
    让 isFlushing = false;
    const render = (vnode, 容器, 命名空间) => {
      如果 (vnode == null) {
        如果（容器._vnode）{
          卸载（容器._vnode，null，null，true）；
        }
      } 别的 {
        修补（
          容器._vnode || 空，
          虚拟节点，
          容器，
          无效的，
          无效的，
          无效的，
          命名空间
        （英文）：
      }
      容器._vnode = vnode;
      如果（！是刷新）{
        是否正在刷新 = true;
        刷新预刷新Cbs()；
        刷新后刷新Cbs()；
        是否刷新 = false;
      }
    };
    const 内部 = {
      p：补丁，
      嗯：卸载，
      m：移动，
      r：删除，
      mt：安装组件，
      mc：挂载子项，
      pc：patchChildren，
      pbc: patchBlockChildren，
      n: 获取下一个主机节点，
      o：选项
    };
    让水分滋润；
    让 hydrateNode；
    如果（createHydrationFns）{
      [hydrate，hydrateNode] = createHydrationFns（
        内部
      （英文）：
    }
    返回 {
      使成为，
      保湿，
      createApp：createAppAPI（渲染，水合物）
    };
  }
  函数 resolveChildrenNamespace({ 类型， props }， currentNamespace) {
    返回 currentNamespace === “svg” && 类型 === “foreignObject” || currentNamespace === “mathml” && 类型 === “annotation-xml” && props && props.encoding && props.encoding.includes(“html”) ? void 0 : currentNamespace;
  }
  函数 toggleRecurse({ 效果， 作业 }， 允许) {
    如果（允许）{
      效果.标志 |= 32;
      作业.标志 |= 4;
    } 别的 {
      效果.标志 &= ~32;
      作业.标志 &= ~4;
    }
  }
  函数 needTransition（parentSuspense，transition）{
    返回（！parentSuspense || parentSuspense && ！parentSuspense.pendingBranch）&& 转换 && ！transition.persisted;
  }
  函数遍历StaticChildren（n1，n2，shallow = false）{
    const ch1 = n1.children;
    const ch2 = n2.children;
    if (isArray(ch1) && isArray(ch2)) {
      对于（让 i = 0; i < ch1.length; i++）{
        const c1 = ch1[i];
        让 c2 = ch2[i];
        如果 (c2.shapeFlag & 1 && !c2.dynamicChildren) {
          如果 (c2.patchFlag <= 0 || c2.patchFlag === 32) {
            c2 = ch2[i] = cloneIfMounted(ch2[i]);
            c2.el = c1.el;
          }
          如果 (!shallow && c2.patchFlag !== -2)
            遍历静态子代（c1，c2）；
        }
        如果（c2.type ===文本）{
          c2.el = c1.el;
        }
        如果 (c2.type === 注释 && !c2.el) {
          c2.el = c1.el;
        }
      }
    }
  }
  函数 getSequence（arr）{
    const p = arr.slice();
    const 结果 = [0];
    让 i，j，u，v，c；
    const len = arr.长度;
    对于（i = 0；i < len；i++）{
      const arrI = arr[i];
      如果 (arrI !== 0) {
        j = 结果[结果.长度 - 1];
        如果 (arr[j] < arrI) {
          p[i] = j;
          结果.推送（i）；
          继续;
        }
        u＝0；
        v = 结果.长度 - 1;
        当 (u < v) {
          c = u + v >> 1;
          如果 (arr[result[c]] < arrI) {
            U=c+1；
          } 别的 {
            v=c；
          }
        }
        如果 (arrI < arr[result[u]]) {
          如果 (u > 0) {
            p[i] = 结果[u - 1];
          }
          结果[u] = i;
        }
      }
    }
    u = 结果.长度;
    v = 结果[u - 1];
    当 (u-- > 0) {
      结果[u] = v;
      v = p[v];
    }
    返回结果；
  }
  函数locateNonHydratedAsyncRoot（实例）{
    const subComponent = 实例.subTree.component;
    如果（子组件）{
      如果 (subComponent.asyncDep && !subComponent.asyncResolved) {
        返回子组件；
      } 别的 {
        返回locateNonHydratedAsyncRoot（subComponent）；
      }
    }
  }
  函数 invalidateMount（hooks）{
    如果（钩子）{
      对于（让 i = 0；i < hooks.length；i++）
        钩子[i].标志|=8；
    }
  }

  const ssrContextKey = Symbol.for("v-scx");
  const useSSRContext = () => {
    {
      warn$1(`useSSRContext() 在全局构建中不受支持。`);
    }
  };

  函数 watchEffect（效果，选项）{
    返回 doWatch（effect，null，options）；
  }
  函数 watchPostEffect (效果，选项) {
    返回 doWatch(
      影响，
      无效的，
      扩展（{}，选项，{刷新：“post”}）
    （英文）：
  }
  函数 watchSyncEffect（效果，选项）{
    返回 doWatch(
      影响，
      无效的，
      扩展（{}，选项，{刷新：“同步”}）
    （英文）：
  }
  函数监视（源，cb，选项）{
    如果 (!isFunction(cb)) {
      警告$1(
        ``watch(fn, options?)`` 签名已移至单独的 API。请改用 ``watchEffect(fn, options?)``。``watch`` 现在仅支持 ``watch(source, cb, options?)` 签名。`
      （英文）：
    }
    返回 doWatch（source，cb，options）；
  }
  函数 doWatch（源，cb，选项 = EMPTY_OBJ）{
    const { 立即，深度，刷新，一次 } = 选项；
    如果（！cb）{
      如果（立即数！== void 0）{
        警告$1(
          `watch()“immediate”选项仅在使用 watch(source,callback,options?) 签名时才受尊重。`
        （英文）：
      }
      如果（深！== void 0）{
        警告$1(
          `watch()“deep”选项仅在使用 watch(source,callback,options?) 签名时才受尊重。`
        （英文）：
      }
      如果（一次！== void 0）{
        警告$1(
          `watch()“once”选项仅在使用 watch(source,callback,options?) 签名时才受尊重。`
        （英文）：
      }
    }
    const baseWatchOptions = 扩展（{}，选项）；
    baseWatchOptions.onWarn = 警告$1;
    const 实例 = 当前实例;
    baseWatchOptions.call = (fn，类型，参数) => callWithAsyncErrorHandling(fn，实例，类型，参数);
    让 isPre = false;
    如果 (flush === "post") {
      baseWatchOptions.scheduler = (作业) => {
        队列后渲染效果（作业，实例&&实例.suspense）；
      };
    } 否则，如果（刷新！==“同步”）{
      是Pre = 真;
      baseWatchOptions.scheduler = (job, isFirstRun) => {
        如果（是第一次运行）{
          工作（）;
        } 别的 {
          队列作业（作业）；
        }
      };
    }
    baseWatchOptions.augmentJob = (工作) => {
      如果（cb）{
        作业.标志 |= 4;
      }
      如果 (isPre) {
        作业.标志 |= 2;
        如果（实例）{
          作业.id = 实例.uid;
          job.i = 实例；
        }
      }
    };
    const watchHandle = watch$1(source，cb，baseWatchOptions);
    返回监视句柄；
  }
  函数 instanceWatch(源，值，选项) {
    const publicThis = this.proxy;
    const getter = isString(source) ? source.includes(".") ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis);
    让 cb；
    如果 (isFunction(值)) {
      cb = 值；
    } 别的 {
      cb = 值.处理程序；
      选项=值；
    }
    重置当前实例
    const res = doWatch（getter， cb.bind（publicThis），选项）;
    重置（）;
    返回 res；
  }
  函数 createPathGetter（ctx，路径）{
    const 段 = 路径.拆分（“。”）;
    返回 () => {
      让 cur = ctx;
      对于（让 i = 0; i < 段.length && cur; i++）{
        cur = cur[段[i]];
      }
      返回 cur；
    };
  }

  函数 useModel(props，name，options = EMPTY_OBJ) {
    获取当前实例
    如果（！我）{
      warn$1(`useModel() 在没有活动实例的情况下被调用。`);
      返回 ref()；
    }
    const camelizedName = camelize（名称）；
    如果 (!i.propsOptions[0][camelizedName]) {
      warn$1(`useModel() 使用未声明的 prop "${name}" 调用。`);
      返回 ref()；
    }
    const hyphenatedName = hyphenate (名称);
    const modifiers = getModelModifiers(props， camelizedName);
    const res = customRef((track, trigger) => {
      让本地值；
      让 prevSetValue = EMPTY_OBJ;
      让 prevEmittedValue；
      watchSyncEffect(() => {
        const propValue = props[camelizedName];
        如果 (hasChanged(localValue，propValue)) {
          本地值 = propValue;
          扳机（）;
        }
      });
      返回 {
        得到（） {
          追踪（）;
          返回 options.get ? options.get(localValue) : localValue;
        }，
        设置（值）{
          const emittedValue = options.set ? options.set(value) : value;
          如果 (!hasChanged(emittedValue，localValue) && !(prevSetValue !== EMPTY_OBJ && hasChanged(value，prevSetValue))) {
            返回;
          }
          const rawProps = i.vnode.props;
          if (!(rawProps && // 检查父级是否已通过 v-model
          (rawProps 中的名称 || rawProps 中的 camelizedName || rawProps 中的 hyphenatedName) && (rawProps 中的`onUpdate:${name}` || rawProps 中的`onUpdate:${camelizedName}` || rawProps 中的`onUpdate:${hyphenatedName}`))) {
            本地值 = 值；
            扳机（）;
          }
          i.emit（`更新：${name}`，emitedValue）；
          如果 (hasChanged(值， emittedValue) && hasChanged(值， prevSetValue) && !hasChanged(emittedValue， prevEmittedValue)) {
            扳机（）;
          }
          上一个设置值 = 值；
          先前发出的值 = 发出的值;
        }
      };
    });
    res[Symbol.迭代器] = () => {
      让 i2 = 0;
      返回 {
        下一个（） {
          如果 (i2 < 2) {
            返回 { 值：i2++？修饰符 || EMPTY_OBJ：res，done：false }；
          } 别的 {
            返回 { 完成： true }；
          }
        }
      };
    };
    返回 res；
  }
  const getModelModifiers = (props，modelName) => {
    返回 modelName === “modelValue” || modelName === “model-value” ? props.modelModifiers : props[`${modelName}Modifiers`] || props[`${camelize(modelName)}Modifiers`] || props[`${hyphenate(modelName)}Modifiers`];
  };

  函数发射（实例，事件，...rawArgs）{
    如果（instance.isUnmounted）返回；
    const props = 实例.vnode.props || EMPTY_OBJ;
    {
      常量 {
        发出选项，
        道具选项：[道具选项]
      } = 实例；
      如果（发出选项）{
        如果 (!(emitsOptions 中的事件) && true) {
          如果 (!propsOptions || !(propsOptions 中的 toHandlerKey(camelize(event))) {
            警告$1(
              `组件发出事件“${event}”，但它既未在 emits 选项中声明，也未作为“${toHandlerKey(camelize(event))}”prop 声明。`
            （英文）：
          }
        } 别的 {
          const 验证器 = emitsOptions[event];
          如果（isFunction（验证器））{
            const isValid = 验证器（...rawArgs）;
            如果（！是有效的）{
              警告$1(
                “无效的事件参数：事件“${event}”的事件验证失败。”
              （英文）：
            }
          }
        }
      }
    }
    让 args = rawArgs;
    const isModelListener = event.startsWith("更新：");
    const modifiers = isModelListener && getModelModifiers(props， event.slice(7));
    if（修饰符）{
      如果（修饰符.trim）{
        args = rawArgs.map((a) => isString(a) ? a.trim() : a);
      }
      如果（修饰符.number）{
        args = rawArgs.map(looseToNumber);
      }
    }
    {
      devtoolsComponentEmit（实例，事件，参数）；
    }
    {
      const lowerCaseEvent = event.toLowerCase();
      如果 (lowerCaseEvent !== 事件 && props[toHandlerKey(lowerCaseEvent)]) {
        警告$1(
          `事件“${lowerCaseEvent}”在组件 ${formatComponentName(
          实例，
          实例类型
        )} 但处理程序已为“${event}”注册。请注意，HTML 属性不区分大小写，在使用 DOM 内模板时，您不能使用 v-on 来监听 camelCase 事件。您可能应该使用“${hyphenate(
          事件
        )}”而不是“${event}”。`
        （英文）：
      }
    }
    让处理程序名称；
    let handler = props[handlerName = toHandlerKey(event)] || // 也尝试 camelCase 事件处理程序 (#2249)
    props[handlerName = toHandlerKey(camelize(event))];
    如果（！处理程序&& isModelListener）{
      处理程序 = props[handlerName = toHandlerKey(连字符(事件))];
    }
    如果（处理程序）{
      调用异步错误处理（
        处理程序，
        实例，
        6、
        参数
      （英文）：
    }
    const onceHandler = props[handlerName + `Once`];
    如果（onceHandler）{
      如果（！实例.发出）{
        实例.发射 = {};
      } 否则，如果 (instance.emitted[handlerName]) {
        返回;
      }
      实例.发出[处理程序名称] = true;
      调用异步错误处理（
        onceHandler，
        实例，
        6、
        参数
      （英文）：
    }
  }
  函数 normalizeEmitsOptions(comp，appContext，asMixin = false) {
    const 缓存 = appContext.emitsCache;
    const 缓存 = cache.get(comp);
    如果（缓存！== void 0）{
      返回缓存；
    }
    const raw = comp.emits;
    让规范化 = {};
    让 hasExtends = false;
    如果 (!isFunction(comp)) {
      const extendEmits = (raw2) => {
        const normalizedFromExtend = normalizeEmitsOptions(raw2， appContext， true);
        如果（normalizedFromExtend）{
          有扩展 = true;
          延伸（规范化，normalizedFromExtend）；
        }
      };
      如果（！asMixin && appContext.mixins.length）{
        appContext.mixins.forEach（扩展Emits）；
      }
      如果 (comp.extends) {
        扩展Emits（comp.扩展）；
      }
      如果（comp.mixins）{
        复制代码
      }
    }
    如果 (!raw && !hasExtends) {
      如果 (isObject(comp)) {
        缓存.设置（comp，null）；
      }
      返回空值；
    }
    如果（isArray（原始））{
      raw.forEach((key) => 标准化[key] = null);
    } 别的 {
      延伸（规范化，原始）；
    }
    如果 (isObject(comp)) {
      缓存.设置（comp，规范化）；
    }
    返回标准化；
  }
  函数 isEmitListener (选项，键) {
    如果 (!options || !isOn(key)) {
      返回 false；
    }
    键 = 键.切片（2）。替换（/Once$/，“”）；
    返回 hasOwn(options, key[0].toLowerCase() + key.slice(1)) || hasOwn(options, hyphenate(key)) || hasOwn(options, key);
  }

  让 accessedAttrs = false;
  函数 markAttrsAccessed() {
    访问属性 = true;
  }
  函数 renderComponentRoot(实例) {
    常量 {
      类型：组件，
      虚拟节点，
      代理人，
      使用代理，
      道具选项： [道具选项]，
      插槽，
      属性，
      发射，
      使成为，
      渲染缓存，
      道具，
      数据，
      设置状态，
      ctx，
      继承属性
    } = 实例；
    const prev = setCurrentRenderingInstance(实例);
    让结果；
    让 fallthroughAttrs；
    {
      访问属性 = false;
    }
    尝试 {
      如果 (vnode.shapeFlag & 4) {
        const proxyToUse = withProxy || 代理；
        const thisProxy = setupState.__isScriptSetup ? new Proxy(proxyToUse, {
          获取（目标，密钥，接收器）{
            警告$1(
              `属性'${String(
              钥匙
            )}'是通过'this'访问的。避免在模板中使用'this'。
            （英文）：
            返回 Reflect.get(目标，键，接收器)；
          }
        }）：代理使用；
        结果 = normalizeVNode（
          渲染.调用（
            这个代理，
            proxyToUse，
            渲染缓存，
            真的吗？ shallowReadonly（props）：道具，
            设置状态，
            数据，
            康普顿
          ）
        （英文）：
        fallthroughAttrs = attrs;
      } 别的 {
        const render2 = 组件;
        如果 (属性 === 道具) {
          标记属性访问情况（）；
        }
        结果 = normalizeVNode（
          render2.长度> 1？render2（
            真的吗？ shallowReadonly（props）：道具，
            真的 ？ {
              获取属性() {
                标记属性访问情况（）；
                返回 shallowReadonly(attrs);
              }，
              插槽，
              发射
            } ：{ 属性， 插槽， 发射 }
          ): 渲染2(
            真的吗？ shallowReadonly（props）：道具，
            无效的
          ）
        （英文）：
        fallthroughAttrs = Component.props ? attrs : getFunctionalFallthrough(attrs);
      }
    } 捕获 (错误) {
      块栈.长度 = 0;
      handleError（错误，实例，1）；
      结果 = 创建VNode（评论）；
    }
    让根=结果；
    让 setRoot = void 0;
    如果 (结果.patchFlag > 0 && 结果.patchFlag & 2048) {
      [root，设置Root] = 获取ChildRoot（结果）；
    }
    如果 (fallthroughAttrs && inheritAttrs !== false) {
      const 键 = Object.keys(fallthroughAttrs);
      const { shapeFlag } = 根；
      如果（键.长度）{
        如果 (shapeFlag & (1 | 6)) {
          如果（propsOptions && keys.some（isModelListener））{
            fallthroughAttrs = filterModelListeners（
              fallthroughAttrs，
              props选项
            （英文）：
          }
          root = cloneVNode（root，fallthroughAttrs，false，true）；
        } 否则，如果 (!accessedAttrs && root.type !== 注释) {
          const allAttrs = Object.keys(attrs);
          const 事件属性 = [];
          const extraAttrs = [];
          对于（让 i = 0，l = allAttrs.length; i < l; i++）{
            const 键 = allAttrs[i];
            如果 (isOn(键)) {
              如果 (!isModelListener(key)) {
                eventAttrs.push(key[2].toLowerCase() + key.slice(3));
              }
            } 别的 {
              extraAttrs.推（键）；
            }
          }
          如果（extraAttrs.length）{
            警告$1(
              `多余的非 props 属性 (${extraAttrs.join(", ")}) 已传递给组件，但无法自动继承，因为组件渲染片段或文本或传送根节点。`
            （英文）：
          }
          如果 (eventAttrs.length) {
            警告$1(
              “无关的非 emits 事件侦听器 (${eventAttrs.join(", ")}) 已传递给组件，但无法自动继承，因为组件会渲染片段或文本根节点。如果侦听器仅用作组件自定义事件侦听器，请使用“emis”选项进行声明。”
            （英文）：
          }
        }
      }
    }
    如果（vnode.dirs）{
      如果 (!isElementRoot(root)) {
        警告$1(
          “运行时指令用于具有非元素根节点的组件。指令将无法按预期发挥作用。”
        （英文）：
      }
      root = cloneVNode（root，null，false，true）；
      root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs;
    }
    如果（vnode.transition）{
      如果 (!isElementRoot(root)) {
        警告$1(
          `<Transition> 内的组件渲染无法动画的非元素根节点。`
        （英文）：
      }
      设置TransitionHooks（根，vnode.transition）；
    }
    如果（设置根）{
      设置Root（根）；
    } 别的 {
      结果 = 根；
    }
    设置当前渲染实例（上一个）；
    返回结果；
  }
  const getChildRoot = (vnode) => {
    const rawChildren = vnode.children;
    const dynamicChildren = vnode.dynamicChildren;
    声明一个过滤器，用于过滤单个根目录下的rawChildren文件。
    如果 (!childRoot) {
      返回[vnode，void 0]；
    } 否则，如果 (childRoot.patchFlag > 0 && childRoot.patchFlag & 2048) {
      返回 getChildRoot(childRoot);
    }
    const index = rawChildren.indexOf(childRoot);
    声明一个动态索引，并且声明一个子索引，那么动态索引的索引值必须是动态索引。
    const setRoot = (更新的根) => {
      rawChildren[索引] = updatedRoot;
      如果（动态儿童）{
        如果（动态索引 > -1）{
          dynamicChildren[dynamicIndex] = updatedRoot;
        } 否则，如果 (updatedRoot.patchFlag > 0) {
          vnode.dynamicChildren = [...dynamicChildren，updatedRoot];
        }
      }
    };
    返回 [normalizeVNode(childRoot), setRoot];
  };
  函数 filterSingleRoot (children，recurse = true) {
    让 singleRoot；
    对于（让 i = 0; i < children.length; i++）{
      const 孩子 = 孩子[i];
      如果 (isVNode(child)) {
        如果（child.type！==注释||child.children===“v-if”）{
          如果（单根）{
            返回;
          } 别的 {
            单根 = 子；
            如果 (递归 && singleRoot.patchFlag > 0 && singleRoot.patchFlag & 2048) {
              返回 filterSingleRoot(singleRoot.children);
            }
          }
        }
      } 别的 {
        返回;
      }
    }
    返回单根；
  }
  const getFunctionalFallthrough = (attrs) => {
    让 res；
    对于（属性中的 const 键）{
      如果 (key === “class” || key === “style” || isOn(key)) {
        (res || (res = {}))[key] = attrs[key];
      }
    }
    返回 res；
  };
  const filterModelListeners = (attrs, props) => {
    常量 res = {};
    对于（属性中的 const 键）{
      如果（！isModelListener（key）||！（key.slice（9）在props中））{
        res[键] = attrs[键];
      }
    }
    返回 res；
  };
  const isElementRoot = (vnode) => {
    返回 vnode.shapeFlag & (6 | 1) || vnode.type === 注释；
  };
  函数 shouldUpdateComponent(prevVNode, nextVNode, 优化) {
    const { props：prevProps， children：prevChildren， component } = prevVNode;
    const { props：nextProps， children：nextChildren， patchFlag } = nextVNode;
    const 发射 = 组件.发射选项;
    如果（（prevChildren || nextChildren）&& isHmrUpdating）{
      返回 true；
    }
    如果（nextVNode.dirs || nextVNode.transition）{
      返回 true；
    }
    如果 (优化 && patchFlag >= 0) {
      如果 (补丁标志 & 1024) {
        返回 true；
      }
      如果 (补丁标志 & 16) {
        如果 (!prevProps) {
          返回 !!nextProps;
        }
        返回 hasPropsChanged(prevProps, nextProps, emits);
      } 否则，如果 (patchFlag & 8) {
        const dynamicProps = nextVNode.dynamicProps;
        对于（让 i = 0; i < dynamicProps.length; i++）{
          const 键 = dynamicProps[i];
          如果 (nextProps[key] !== prevProps[key] && !isEmitListener(emits, key)) {
            返回 true；
          }
        }
      }
    } 别的 {
      如果 (上一个孩子 || 下一个孩子) {
        如果（！nextChildren || ！nextChildren。$stable）{
          返回 true；
        }
      }
      如果 (prevProps === nextProps) {
        返回 false；
      }
      如果 (!prevProps) {
        返回 !!nextProps;
      }
      如果 (!nextProps) {
        返回 true；
      }
      返回 hasPropsChanged(prevProps, nextProps, emits);
    }
    返回 false；
  }
  函数 hasPropsChanged(prevProps, nextProps, emitsOptions) {
    const nextKeys = Object.keys(nextProps);
    如果 (nextKeys.length !== Object.keys(prevProps).length) {
      返回 true；
    }
    对于（让 i = 0；i < nextKeys.length；i++）{
      const 键 = nextKeys[i];
      如果 (nextProps[key] !== prevProps[key] && !isEmitListener(emitsOptions, key)) {
        返回 true；
      }
    }
    返回 false；
  }
  函数更新HOCHostEl({ vnode， 父节点 }， el) {
    while (父级) {
      const 根 = 父级.子树;
      如果 (root.suspense && root.suspense.activeBranch === vnode) {
        根节点.el = vnode.el;
      }
      如果（根=== vnode）{
        (vnode = 父节点.vnode).el = el;
        父母=父母。父母；
      } 别的 {
        休息;
      }
    }
  }

  const isSuspense = (type) => type.__isSuspense;
  让 suspenseId = 0;
  const SuspenseImpl = {
    名称：《悬疑》，
    // 为了让 Suspense 可进行 tree-shak 操作，我们需要避免导入它
    // 直接在渲染器中。渲染器检查 __isSuspense 标志
    // 根据 vnode 的类型调用 `process` 方法，并传入渲染器
    // 内部。
    __isSuspense: true，
    进程（n1，n2，容器，锚点，parentComponent，parentSuspense，命名空间，slotScopeIds，优化，rendererInternals）{
      如果 (n1 == 空) {
        mountSuspense（
          n2，
          容器，
          锚，
          父组件，
          父级悬念，
          命名空间，
          slotScopeIds，
          优化，
          渲染器内部
        （英文）：
      } 别的 {
        if (parentSuspense && ParentSuspense.deps > 0 && !n1.suspense.isInFallback) {
          n2.悬念 = n1.悬念；
          n2.suspense.vnode = n2;
          n2.el = n1.el;
          返回;
        }
        patchSuspense（
          n1，
          n2，
          容器，
          锚，
          父组件，
          命名空间，
          slotScopeIds，
          优化，
          渲染器内部
        （英文）：
      }
    }，
    水合物：hydrateSuspense，
    规范化：normalizeSuspenseChildren
  };
  常量 Suspense = SuspenseImpl ;
  函数触发事件（vnode，名称）{
    const eventListener = vnode.props && vnode.props[name];
    if (isFunction(eventListener)) {
      事件监听器（）；
    }
  }
  函数 mountSuspense(vnode, 容器, 锚点, parentComponent, parentSuspense, 命名空间, slotScopeIds, 优化, rendererInternals) {
    常量 {
      p：补丁，
      o：{ 创建元素 }
    } = 渲染器内部；
    const hiddenContainer = createElement("div");
    const suspense = vnode.suspense = createSuspenseBoundary(
      虚拟节点，
      父级悬念，
      父组件，
      容器，
      隐藏容器，
      锚，
      命名空间，
      slotScopeIds，
      优化，
      渲染器内部
    （英文）：
    修补（
      无效的，
      suspense.pendingBranch = vnode.ssContent，
      隐藏容器，
      无效的，
      父组件，
      悬念，
      命名空间，
      slotScopeIds
    （英文）：
    如果（suspense.deps> 0）{
      触发事件（vnode， “onPending”）；
      触发事件（vnode，“onFallback”）；
      修补（
        无效的，
        vnode.ssFallback，
        容器，
        锚，
        父组件，
        无效的，
        // 回退树将不会有悬念上下文
        命名空间，
        slotScopeIds
      （英文）：
      设置ActiveBranch（suspense，vnode.ssFallback）；
    } 别的 {
      悬念.解决（false，true）；
    }
  }
  函数 patchSuspense(n1，n2，容器，锚点，parentComponent，命名空间，slotScopeIds，优化，{ p：patch，um：unmount，o：{createElement }}) {
    const 悬念 = n2.悬念 = n1.悬念;
    suspense.vnode = n2;
    n2.el = n1.el;
    const newBranch = n2.ssContent;
    const newFallback = n2.ssFallback;
    const { activeBranch，pendingBranch，isInFallback，isHydrating } = suspense;
    如果（待处理分支）{
      suspense.pendingBranch = newBranch;
      如果 (isSameVNodeType(newBranch，pendingBranch)) {
        修补（
          待处理分支，
          新分支，
          suspense.hiddenContainer， 复制代码
          无效的，
          父组件，
          悬念，
          命名空间，
          slotScopeIds，
          优化
        （英文）：
        如果 (suspense.deps <= 0) {
          悬念.解决（）；
        } 否则，如果 (isInFallback) {
          如果（！是Hydrating）{
            修补（
              activeBranch，
              newFallback，
              容器，
              锚，
              父组件，
              无效的，
              // 回退树将不会有悬念上下文
              命名空间，
              slotScopeIds，
              优化
            （英文）：
            设置ActiveBranch（suspense，newFallback）；
          }
        }
      } 别的 {
        suspense.pendingId = suspenseId++;
        如果（是保湿的）{
          suspense.isHydrating = false;
          suspense.activeBranch = penaltyBranch; 复制代码
        } 别的 {
          卸载（pendingBranch，parentComponent，暂停）；
        }
        暂停.deps = 0;
        悬念.效果.长度 = 0;
        suspense.hiddenContainer = createElement("div");
        如果（isInFallback）{
          修补（
            无效的，
            新分支，
            suspense.hiddenContainer， 复制代码
            无效的，
            父组件，
            悬念，
            命名空间，
            slotScopeIds，
            优化
          （英文）：
          如果 (suspense.deps <= 0) {
            悬念.解决（）；
          } 别的 {
            修补（
              activeBranch，
              newFallback，
              容器，
              锚，
              父组件，
              无效的，
              // 回退树将不会有悬念上下文
              命名空间，
              slotScopeIds，
              优化
            （英文）：
            设置ActiveBranch（suspense，newFallback）；
          }
        } 否则，如果 (activeBranch && isSameVNodeType(newBranch，activeBranch)) {
          修补（
            activeBranch，
            新分支，
            容器，
            锚，
            父组件，
            悬念，
            命名空间，
            slotScopeIds，
            优化
          （英文）：
          悬念.解决（真）；
        } 别的 {
          修补（
            无效的，
            新分支，
            suspense.hiddenContainer， 复制代码
            无效的，
            父组件，
            悬念，
            命名空间，
            slotScopeIds，
            优化
          （英文）：
          如果 (suspense.deps <= 0) {
            悬念.解决（）；
          }
        }
      }
    } 别的 {
      如果 (activeBranch && isSameVNodeType(newBranch，activeBranch)) {
        修补（
          activeBranch，
          新分支，
          容器，
          锚，
          父组件，
          悬念，
          命名空间，
          slotScopeIds，
          优化
        （英文）：
        设置ActiveBranch（suspense，newBranch）；
      } 别的 {
        触发事件（n2，“onPending”）；
        suspense.pendingBranch = newBranch;
        如果 (newBranch.shapeFlag & 512) {
          suspense.pendingId = newBranch.component.suspenseId;
        } 别的 {
          suspense.pendingId = suspenseId++;
        }
        修补（
          无效的，
          新分支，
          suspense.hiddenContainer， 复制代码
          无效的，
          父组件，
          悬念，
          命名空间，
          slotScopeIds，
          优化
        （英文）：
        如果 (suspense.deps <= 0) {
          悬念.解决（）；
        } 别的 {
          const { 超时，pendingId } = 悬而未决；
          如果（超时 > 0）{
            设置超时（（）=> {
              如果 (suspense.pendingId === pengingId) {
                suspense.fallback（newFallback）；
              }
            }， 暂停）;
          } 否则，如果 (超时 === 0) {
            suspense.fallback（newFallback）；
          }
        }
      }
    }
  }
  让 hasWarned = false;
  函数 createSuspenseBoundary(vnode、parentSuspense、parentComponent、container、hiddenContainer、anchor、namespace、slotScopeIds、optimized、rendererInternals、isHydrating = false) {
    如果 (!hasWarned) {
      已警告 = 真；
      控制台[console.info ? "info" : "log"](
        `<Suspense> 是一个实验性功能，其 API 可能会改变。`
      （英文）：
    }
    常量 {
      p：补丁，
      m：移动，
      嗯：卸载，
      n：接下来，
      o: { 父节点， 删除 }
    } = 渲染器内部；
    让 parentSuspenseId；
    const isSuspensible = isVNodeSuspensible(vnode);
    如果（可暂停）{
      如果 (parentSuspense && parentSuspense.pendingBranch) {
        ParentSuspenseId = ParentSuspense.pendingId;
        父Suspense.deps++；
      }
    }
    const timeout = vnode.props？toNumber（vnode.props.timeout）：void 0；
    {
      assertNumber(timeout, `暂停超时`);
    }
    const 初始锚 = 锚;
    const 悬念 = {
      虚拟节点，
      父母：parentSuspense，
      父组件，
      命名空间，
      容器，
      隐藏容器，
      依赖： 0，
      待处理 ID：suspenseId++，
      超时：超时类型 ===“number”？超时：-1，
      activeBranch：空，
      待处理分支：null，
      isInFallback: !isHydrating,
      保湿，
      未安装：false，
      效果：[]，
      解决（恢复 = false，同步 = false）{
        {
          如果（！恢复&&！suspense.pendingBranch）{
            抛出新的错误（
              `suspense.resolve() 在没有待处理分支的情况下被调用。`
            （英文）：
          }
          如果（suspense.isUnmounted）{
            抛出新的错误（
              `suspense.resolve() 在已经卸载的悬念边界上被调用。`
            （英文）：
          }
        }
        常量 {
          vnode：vnode2，
          activeBranch，
          待处理分支，
          待处理 ID，
          效果，
          父组件：父组件2，
          容器：container2
        } = 悬念；
        让 delayEnter = false;
        如果（suspense.isHydrating）{
          suspense.isHydrating = false;
        } 否则，如果（！恢复）{
          delayEnter = activeBranch && penaltyBranch.transition && penaltyBranch.transition.mode === “出-入”;
          如果（延迟输入）{
            activeBranch.transition.afterLeave = () => {
              如果 (pendingId === suspense.pendingId) {
                移动（
                  待处理分支，
                  容器2，
                  锚点 === initialAnchor ? 下一个 (activeBranch) : 锚点，
                  0
                （英文）：
                队列PostFlushCb（效果）；
              }
            };
          }
          如果（活动分支）{
            如果 (parentNode(activeBranch.el) === container2) {
              锚点 = 下一个 (activeBranch)；
            }
            卸载（activeBranch，parentComponent2，suspense，true）；
          }
          如果 (!delayEnter) {
            移动（pendingBranch，container2，锚点，0）；
          }
        }
        设置ActiveBranch（暂停，待处理分支）；
        suspense.pendingBranch = null;
        suspense.isInFallback = false;
        让父母 = suspense.parent;
        让 hasUnresolvedAncestor = false;
        while (父级) {
          如果（父级。pendingBranch）{
            父母.效果.推送（...效果）；
            hasUnresolvedAncestor = true;
            休息;
          }
          父母=父母。父母；
        }
        如果 (!hasUnresolvedAncestor && !delayEnter) {
          队列PostFlushCb（效果）；
        }
        悬念.效果 = [];
        如果（可暂停）{
          如果 (parentSuspense && parentSuspense.pendingBranch && parentSuspenseId === parentSuspense.pendingId) {
            父Suspense.deps--;
            如果 (parentSuspense.deps === 0 && !sync) {
              父Suspense.resolve()；
            }
          }
        }
        触发事件（vnode2，“onResolve”）；
      }，
      fallback(fallbackVNode) {
        如果 (!suspense.pendingBranch) {
          返回;
        }
        const { vnode：vnode2，activeBranch，parentComponent：parentComponent2，容器：container2，命名空间：namespace2} = suspense;
        触发事件（vnode2，“onFallback”）；
        const anchor2 = next(activeBranch);
        const mountFallback = () => {
          如果 (!suspense.isInFallback) {
            返回;
          }
          修补（
            无效的，
            fallbackVNode，
            容器2，
            锚点2，
            父组件2，
            无效的，
            // 回退树将不会有悬念上下文
            命名空间2，
            slotScopeIds，
            优化
          （英文）：
          设置ActiveBranch（suspense，fallbackVNode）；
        };
        const delayEnter = fallbackVNode.transition && fallbackVNode.transition.mode === "出-入";
        如果（延迟输入）{
          激活分支.转换.离开后 = mountFallback;
        }
        suspense.isInFallback = true;
        卸载（
          activeBranch，
          父组件2，
          无效的，
          // 没有悬念，因此卸载钩子现在触发
          真的
          // 应该删除
        （英文）：
        如果 (!delayEnter) {
          安装回退（）；
        }
      }，
      移动（容器2，锚点2，类型）{
        suspense.activeBranch && 移动（suspense.activeBranch，container2，anchor2，type）；
        suspense.container = container2;
      }，
      下一个（） {
        返回 suspense.activeBranch && next(suspense.activeBranch);
      }，
      registerDep（实例，setupRenderEffect，optimized2）{
        const isInPendingSuspense = !!suspense.pendingBranch;
        如果（isInPendingSuspense）{
          悬念.deps++；
        }
        const hydratedEl = 实例.vnode.el;
        实例.asyncDep.catch((err) => {
          handleError（错误，实例，0）；
        }).then((asyncSetupResult) => {
          如果 (instance.isUnmounted || suspense.isUnmounted || suspense.pendingId !== instance.suspenseId) {
            返回;
          }
          实例.asyncResolved = true;
          const { vnode: vnode2 } = 实例；
          {
            推送警告上下文（vnode2）；
          }
          handleSetupResult（实例，asyncSetupResult，false）；
          如果 (hydratedEl) {
            vnode2.el = hydratedEl;
          }
          const 占位符 = !hydratedEl && 实例.subTree.el;
          设置渲染效果（
            实例，
            vnode2，
            // 组件可能在解析之前已经被移动。
            // 如果这不是水合，则 instance.subTree 将是注释
            //占位符。
            父节点（hydratedEl || instance.subTree.el），
            // 如果这是水合，则不使用锚点，因此只需要
            // 考虑注释占位符的情况。
            hydratedEl ? null : next(instance.subTree),
            悬念，
            命名空间，
            优化2
          （英文）：
          如果（占位符）{
            删除（占位符）；
          }
          更新HOCHostEl（实例，vnode2.el）；
          {
            弹出警告上下文()；
          }
          if (isInPendingSuspense && --suspense.deps === 0) {
            悬念.解决（）；
          }
        });
      }，
      卸载（parentSuspense2，doRemove）{
        suspense.isUnmounted = true;
        如果（suspense.activeBranch）{
          卸载（
            suspense.activeBranch，
            父组件，
            父Suspense2，
            删除
          （英文）：
        }
        如果（suspense.pendingBranch）{
          卸载（
            suspense.pendingBranch，
            父组件，
            父Suspense2，
            删除
          （英文）：
        }
      }
    };
    回归悬念；
  }
  函数 hydrateSuspense(node, vnode, parentComponent, parentSuspense, namespace, slotScopeIds,optimized, rendererInternals, hydrateNode) {
    const suspense = vnode.suspense = createSuspenseBoundary(
      虚拟节点，
      父级悬念，
      父组件，
      节点.parentNode，
      // eslint-禁用下一行无限制全局变量
      document.createElement(“div”)，
      无效的，
      命名空间，
      slotScopeIds，
      优化，
      渲染器内部，
      真的
    （英文）：
    const 结果 = hydrateNode(
      节点，
      suspense.pendingBranch = vnode.ssContent，
      父组件，
      悬念，
      slotScopeIds，
      优化
    （英文）：
    如果 (suspense.deps === 0) {
      悬念.解决（false，true）；
    }
    返回结果；
  }
  函数 normalizeSuspenseChildren (vnode) {
    const { shapeFlag， children } = vnode；
    const isSlotChildren = shapeFlag & 32;
    vnode.ssContent = normalizeSuspenseSlot（
      isSlotChildren ? children.default : children
    （英文）：
    vnode.ssFallback = isSlotChildren ? normalizeSuspenseSlot(children.fallback) : createVNode(评论);
  }
  函数 normalizeSuspenseSlot(s) {
    讓阻止；
    如果 (isFunction(s)) {
      const trackBlock = isBlockTreeEnabled && s._c;
      如果（trackBlock）{
        s._d = 假;
        打开块（）；
      }
      s = s();
      如果（trackBlock）{
        s._d = 真；
        块=当前块；
        关闭块（）；
      }
    }
    如果 (isArray(s)) {
      定义一个过滤器singleRoot，如下所示：
      如果 (!singleChild && s.filter((child) => child !== NULL_DYNAMIC_COMPONENT).length > 0) {
        warn$1(`<Suspense> 插槽需要一个根节点。`);
      }
      s = 单个孩子；
    }
    s = 正常化VNode(s);
    如果（块&&！s.dynamicChildren）{
      s.dynamicChildren = block.filter((c) => c !== s);
    }
    返回 s；
  }
  函数queueEffectWithSuspense（fn，suspense）{
    如果（suspense && suspense.pendingBranch）{
      如果 (isArray (fn)) {
        悬念.效果.推送（...fn）；
      } 别的 {
        悬念.效果.推送（fn）；
      }
    } 别的 {
      队列PostFlushCb（fn）；
    }
  }
  函数 setActiveBranch (suspense，branch) {
    suspense.activeBranch = 分支;
    const { vnode， parentComponent } = suspense;
    让 el = 分支.el;
    while (!el && 分支.组件) {
      分支 = 分支.组件.子树;
      el = 分支.el;
    }
    vnode.el = el;
    如果 (parentComponent && parentComponent.subTree === vnode) {
      ParentComponent.vnode.el = el;
      更新HOCHostEl（父组件， el）；
    }
  }
  函数 isVNodeSuspensible(vnode) {
    const suspensible = vnode.props && vnode.props.suspensible;
    返回 suspensible != null && suspensible !== false;
  }

  const Fragment = Symbol.for(“v-fgt”);
  const Text = Symbol.for("v-txt");
  const 注释 = Symbol.for("v-cmt");
  const Static = Symbol.for(“v-stc”);
  const 块堆栈 = [];
  让 currentBlock = null;
  函数 openBlock(disableTracking = false) {
    blockStack.推（currentBlock = disableTracking？null：[]）；
  }
  函数 closeBlock() {
    块堆栈.pop()；
    当前块 = 块堆栈 [ 块堆栈.长度 - 1 ] || 空;
  }
  让isBlockTreeEnabled = 1;
  函数 setBlockTracking（值，inVOnce = false）{
    isBlockTreeEnabled += 值；
    如果 (值 < 0 && currentBlock && inVOnce) {
      当前块.hasOnce = true;
    }
  }
  函数setupBlock（vnode）{
    vnode.dynamicChildren = isBlockTreeEnabled > 0 ？当前块|| EMPTY_ARR：空；
    关闭块（）；
    if (isBlockTreeEnabled > 0 && currentBlock) {
      当前块.推送（vnode）；
    }
    返回vnode；
  }
  函数 createElementBlock(类型，道具，儿童，patchFlag，dynamicProps，shapeFlag) {
    返回设置块（
      创建BaseVNode（
        类型，
        道具，
        孩子们，
        补丁标志，
        dynamicProps，
        形状标志，
        真的
      ）
    （英文）：
  }
  函数 createBlock(类型，道具，儿童，补丁标志，动态道具) {
    返回设置块（
      创建VNode（
        类型，
        道具，
        孩子们，
        补丁标志，
        dynamicProps，
        真的
      ）
    （英文）：
  }
  函数 isVNode (值) {
    返回值？值.__v_isVNode === true : false;
  }
  函数 isSameVNodeType(n1，n2) {
    如果 (n2.shapeFlag & 6 && n1.component) {
      const dirtyInstances = hmrDirtyComponents.get(n2.type);
      如果 (dirtyInstances && dirtyInstances.has(n1.component)) {
        n1.形状标志&=~256；
        n2.形状标志&=~512；
        返回 false；
      }
    }
    返回 n1.type === n2.type && n1.key === n2.key;
  }
  让 vnodeArgsTransformer；
  函数transformVNodeArgs（变压器）{
    vnodeArgsTransformer = 变压器；
  }
  const createVNodeWithArgsTransform = (...args) => {
    返回 _createVNode(
      ...vnodeArgsTransformer？vnodeArgsTransformer（args，currentRenderingInstance）：args
    （英文）：
  };
  const normalizeKey = ({ key }) => key != null ? key : null;
  const normalizeRef = （{
    参考，
    ref_key，
    ref_for
  }）=> {
    如果 (typeof ref === “number”) {
      参考 = “” + 参考;
    }
    返回 ref != null ? isString(ref) || isRef(ref) || isFunction(ref) ? { i: currentRenderingInstance, r: ref, k: ref_key, f: !!ref_for } : ref : null;
  };
  函数 createBaseVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, shapeFlag = type === Fragment ? 0 : 1, isBlockNode = false, needFullChildrenNormalization = false) {
    const vnode = {
      __v_isVNode: true，
      __v_skip: true，
      类型，
      道具，
      键： props && normalizeKey(props)，
      ref: props && normalizeRef(props),
      scopeId：当前ScopeId，
      slotScopeIds：null，
      孩子们，
      组件：null，
      悬念：null，
      ssContent：空，
      ssFallback: 空，
      目录：null，
      转换：null，
      el: 空，
      锚点：null，
      目标：null，
      目标开始：null，
      targetAnchor：空，
      静态计数： 0，
      形状标志，
      补丁标志，
      dynamicProps，
      dynamicChildren：空，
      appContext：空，
      ctx：当前渲染实例
    };
    如果（需要FullChildrenNormalization）{
      正常化儿童（vnode，儿童）；
      如果 (shapeFlag & 128) {
        类型.规范化（vnode）；
      }
    } 否则，如果 (子项) {
      vnode.shapeFlag |= isString(children) ?8 : 16;
    }
    如果（vnode.key !== vnode.key）{
      warn$1(`使用无效键 (NaN) 创建的 VNode。VNode 类型：`, vnode.type);
    }
    if (isBlockTreeEnabled > 0 && // 避免块节点跟踪自身
    !isBlockNode && // 有当前父块
    currentBlock && // 补丁标志的存在表明该节点需要在更新时进行修补。
    // 组件节点也应该始终进行修补，因为即使
    // 组件不需要更新，它需要将实例持久化到
    // 下一个 vnode，以便稍后可以正确卸载。
    (vnode.patchFlag > 0 || shapeFlag & 6) && // EVENTS 标志仅用于水合，如果它是唯一的标志，则
    // 由于处理程序缓存，vnode 不应被视为动态。
    vnode.patchFlag !== 32) {
      当前块.推送（vnode）；
    }
    返回vnode；
  }
  复制代码
  函数 _createVNode(类型，props = null，children = null，patchFlag = 0，dynamicProps = null，isBlockNode = false) {
    如果（！类型||类型=== NULL_DYNAMIC_COMPONENT）{
      如果（！类型）{
        warn$1(`创建 vnode 时 vnode 类型无效：${type}。`);
      }
      类型=评论；
    }
    如果 (isVNode(类型)) {
      const cloned = cloneVNode（
        类型，
        道具，
        真的
        /*mergeRef：真*/
      （英文）：
      如果（孩子）{
        正常化儿童（克隆，儿童）；
      }
      if (isBlockTreeEnabled > 0 && !isBlockNode && currentBlock) {
        如果（cloned.shapeFlag & 6）{
          currentBlock[currentBlock.indexOf(类型)] = 克隆；
        } 别的 {
          currentBlock.推送（克隆）；
        }
      }
      克隆.patchFlag = -2;
      返回克隆；
    }
    如果 (isClassComponent(类型)) {
      类型=类型.__vccOpts；
    }
    如果（道具）{
      属性 = guardReactiveProps (属性);
      让 { class：klass，style } = props；
      if (klass && !isString(klass)) {
        props.class = normalizeClass(klass);
      }
      如果（isObject（样式））{
        如果（isProxy（样式）&&！isArray（样式））{
          样式 = 扩展（{}，样式）；
        }
        props.style = normalizeStyle(风格);
      }
    }
    const shapeFlag = isString(类型) ? 1：isSuspense（类型）？ 128：isTeleport（类型）？ 64：isObject（类型）？ 4：isFunction（类型）？ 2：0；
    如果 (shapeFlag & 4 && isProxy(类型)) {
      类型 = toRaw(类型);
      警告$1(
        “Vue 收到一个被设为反应性对象的组件。这可能会导致不必要的性能开销，应通过使用 \`markRaw\` 标记组件或使用 \`shallowRef\` 而不是 \`ref\` 来避免这种情况。”，
        `
已变为反应性的组件：`，
        类型
      （英文）：
    }
    返回 createBaseVNode（
      类型，
      道具，
      孩子们，
      补丁标志，
      dynamicProps，
      形状标志，
      是区块节点，
      真的
    （英文）：
  }
  函数 guardReactiveProps(props) {
    如果（！props）返回null；
    返回 isProxy(props) || isInternalObject(props) ? extend({}, props) : props;
  }
  函数 cloneVNode（vnode，extraProps，mergeRef = false，cloneTransition = false）{
    const { props, ref, patchFlag, children, transition } = vnode;
    const mergeProps = extraProps ? mergeProps(props || {}, extraProps) : props;
    const 克隆 = {
      __v_isVNode: true，
      __v_skip: true，
      类型：vnode.type，
      道具：mergedProps，
      键：mergedProps && normalizeKey（mergedProps），
      ref：extraProps && extraProps.ref？（
        // #2078 在 <component :is="vnode" ref="extra"/> 的情况下
        // 如果 vnode 本身已经有一个 ref，则 cloneVNode 需要合并
        // refs，因此单个 vnode 可以在多个 refs 上设置
        mergeRef && ref ? isArray(ref) ? ref.concat(normalizeRef(extraProps)) : [ref, normalizeRef(extraProps)] : normalizeRef(extraProps)
      ): 参考，
      scopeId: vnode.scopeId，
      slotScopeIds：vnode.slotScopeIds，
      孩子：patchFlag === -1 && isArray（孩子）？孩子。map（deepCloneVNode）：孩子们，
      目标：vnode.target，
      目标开始：vnode.目标开始，
      目标锚点：vnode.目标锚点，
      静态计数：vnode.静态计数，
      形状标志：vnode.shapeFlag，
      // 如果 vnode 被克隆时带有额外的 props，我们就不能再假设它的
      // 现有的补丁标志是可靠的，需要添加 FULL_PROPS 标志。
      // 注意：保留 fragment 的标志，因为它们使用子 fragment 的标志
      // 仅限快速路径。
      patchFlag：extraProps && vnode.type !==片段？patchFlag === -1？16：patchFlag | 16：patchFlag，
      dynamicProps：vnode.dynamicProps，
      动态子节点：vnode.动态子节点，
      appContext：vnode.appContext，
      目录：vnode.dirs，
      过渡，
      // 从技术上讲，这些应该只在已安装的 VNode 上为非空。但是，
      // 它们*应该*被复制以保持活跃的 vnode。所以我们总是复制
      // 因为它们在挂载期间为非空，所以不会影响逻辑
      // 它们将会被简单地覆盖。
      组件：vnode.component，
      悬念：vnode.suspense，
      ssContent：vnode.ssContent && cloneVNode（vnode.ssContent），
      ssFallback：vnode.ssFallback && cloneVNode（vnode.ssFallback），
      el：vnode.el，
      锚点：vnode.anchor，
      ctx：vnode.ctx，
      ce: vnode.ce
    };
    如果（转换&& cloneTransition）{
      设置TransitionHooks（
        克隆，
        transition.clone（克隆）
      （英文）：
    }
    返回克隆；
  }
  函数 deepCloneVNode (vnode) {
    const clone = cloneVNode（vnode）；
    如果（isArray（vnode.children））{
      克隆.children = vnode.children.map(deepCloneVNode);
    }
    返回克隆；
  }
  函数 createTextVNode(text = " ", flag = 0) {
    返回 createVNode(Text, null, text, flag);
  }
  函数 createStaticVNode（内容，节点数）{
    const vnode = createVNode(Static, null, content);
    vnode.静态计数 = 节点数;
    返回vnode；
  }
  函数 createCommentVNode（text =“”，asBlock = false）{
    返回 asBlock ？ (openBlock()，createBlock(Comment，null，text)) ：createVNode(Comment，null，text);
  }
  函数 normalizeVNode （ child ） {
    如果 (child == null || typeof child === “boolean”) {
      返回 createVNode（评论）；
    } 否则，如果 (isArray (child)) {
      返回 createVNode（
        分段，
        无效的，
        // #3666，重用 vnode 时避免引用污染
        子级.slice()
      （英文）：
    } 否则，如果 (isVNode(child)) {
      返回 cloneIfMounted（child）；
    } 别的 {
      返回 createVNode(Text, null, String(child));
    }
  }
  函数 cloneIfMounted（子）{
    返回 child.el === null && child.patchFlag !== -1 || child.memo ? child : cloneVNode(child);
  }
  函数 normalizeChildren(vnode，children) {
    让类型=0；
    const { shapeFlag } = vnode;
    如果 (children == null) {
      孩子=空；
    } 否则，如果 (isArray (children)) {
      类型=16；
    } 否则，如果 (typeof children === “object”) {
      如果 (shapeFlag & (1 | 64)) {
        const 槽 = children.default;
        如果（槽）{
          插槽._c && (插槽._d = false);
          正常化Children（vnode，slot（））;
          插槽._c && (插槽._d = true);
        }
        返回;
      } 别的 {
        类型=32；
        const slotFlag = children._;
        如果 (!slotFlag && !isInternalObject(children)) {
          儿童。_ctx = 当前渲染实例；
        } 否则，如果 (slotFlag === 3 && currentRenderingInstance) {
          如果 (currentRenderingInstance.slots._ === 1) {
            孩子。_ = 1;
          } 别的 {
            孩子。_ = 2;
            vnode.补丁标志 |= 1024;
          }
        }
      }
    } 否则，如果 (isFunction(children)) {
      子级 = { 默认值：子级，_ctx：currentRenderingInstance };
      类型=32；
    } 别的 {
      孩子 = 字符串（孩子）;
      如果 (shapeFlag & 64) {
        类型=16；
        子节点 = [创建TextVNode(子节点)];
      } 别的 {
        类型=8；
      }
    }
    vnode.children = children;
    vnode.shapeFlag |=类型；
  }
  函数mergeProps（...args）{
    常量 ret = {};
    对于（让 i = 0；i < args.length；i++）{
      复制代码
      对于（toMerge 中的 const 键）{
        如果 (键 === “类”) {
          如果 (ret.class !== toMerge.class) {
            ret.class = normalizeClass([ret.class， toMerge.class]);
          }
        }否则，如果（键===“样式”）{
          ret.style = normalizeStyle（[ret.style，toMerge.style]）；
        } 否则，如果 (isOn(key)) {
          const 现有 = ret[key];
          const 传入 = toMerge[key];
          如果 (传入 && 现有 !== 传入 && !(isArray(现有) && 现有.包括(传入))) {
            ret[key] = 现有的？[].concat(现有的，传入) ：传入；
          }
        } 否则，如果（键 !==“”）{
          ret[key] = toMerge[key];
        }
      }
    }
    返回 ret；
  }
  函数invokeVNodeHook（hook，实例，vnode，prevVNode = null）{
    callWithAsyncErrorHandling（钩子，实例，7，[
      虚拟节点，
      上一个VNode
    ]);
  }

  const emptyAppContext = createAppContext();
  让 uid = 0;
  函数 createComponentInstance (vnode，parent，suspense) {
    const 类型 = vnode.类型;
    const appContext = (父级？父级.appContext：vnode.appContext) || 空AppContext;
    const 实例 = {
      uid：uid++，
      虚拟节点，
      类型，
      父母，
      应用程序上下文，
      根：空，
      // 立即设置
      下一个：null，
      子树：null，
      // 创建后将同步设置
      效果：无效，
      更新：null，
      // 创建后将同步设置
      作业：null，
      范围：新的 EffectScope（
        真的
        /* 分离 */
      ),
      渲染：null，
      代理：null，
      暴露：null，
      暴露代理：null，
      withProxy: null，
      提供：父母？父母.提供：Object.create（appContext.提供），
      ID：父母？父母.ID：[“”，0，0]，
      访问缓存：null，
      渲染缓存：[]，
      // 本地解析资产
      组件：null，
      指令：null，
      // 解析 props 并发出选项
      propsOptions：normalizePropsOptions（类型，appContext），
      发出选项：normalizeEmitsOptions（类型，appContext），
      // 发出
      发射：null，
      // 立即设置
      发射：null，
      // props 默认值
      propsDefaults: EMPTY_OBJ，
      // 继承属性
      继承属性：类型.继承属性，
      // 状态
      ctx：空对象，
      数据：EMPTY_OBJ，
      道具：EMPTY_OBJ，
      属性：EMPTY_OBJ，
      插槽：EMPTY_OBJ，
      参考：EMPTY_OBJ，
      设置状态：EMPTY_OBJ，
      setupContext：null，
      // 悬念相关
      悬念，
      suspenseId： 悬念？suspense.pendingId： 0，
      asyncDep: 空，
      异步解析：false，
      // 生命周期钩子
      // 这里不使用枚举，因为它会导致计算属性
      是否已安装：false，
      未安装：false，
      已停用：false，
      bc：空，
      c: 空，
      bm：空，
      m：空，
      bu：空，
      u：空，
      嗯：null，
      bum：null，
      da：空，
      答：空，
      rtg：空，
      rtc: 空，
      ec: 空，
      sp：空
    };
    {
      实例.ctx = 创建DevRenderContext（实例）；
    }
    实例.root = 父级？父级.root：实例；
    实例.发射 = 发射.绑定（null，实例）；
    如果（vnode.ce）{
      vnode.ce（实例）；
    }
    返回实例；
  }
  让 currentInstance = null;
  const getCurrentInstance = () => currentInstance || currentRenderingInstance;
  让内部设置当前实例；
  让 setInSSRSetupState；
  {
    internalSetCurrentInstance = （i）=> {
      当前实例 = i;
    };
    设置SSRSetupState = (v) => {
      是否在SSR组件设置中 = v;
    };
  }
  const setCurrentInstance = (实例) => {
    const prev = currentInstance;
    内部设置当前实例（实例）；
    实例.范围.on()；
    返回 () => {
      实例.范围.关闭（）；
      内部设置当前实例（上一个）；
    };
  };
  const unsetCurrentInstance = () => {
    当前实例 && 当前实例.范围.关闭();
    内部设置当前实例（空）；
  };
  const isBuiltInTag = /* @__PURE__ */ makeMap("slot,component");
  函数validateComponentName（名称，{isNativeTag}）{
    如果（isBuiltInTag（名称）|| isNativeTag（名称））{
      警告$1(
        “请勿使用内置或保留的 HTML 元素作为组件 id：”+ 名称
      （英文）：
    }
  }
  函数 isStatefulComponent（实例）{
    返回实例.vnode.shapeFlag & 4;
  }
  让 isInSSRComponentSetup = false;
  函数setupComponent（实例，isSSR = false，优化= false）{
    isSSR && setInSSRSetupState(isSSR);
    const { props，children } = instance.vnode;
    const isStateful = isStatefulComponent(实例);
    initProps（实例，道具，isStateful，isSSR）；
    initSlots（实例，子项，优化）；
    const setupResult = isStateful？setupStatefulComponent（instance，isSSR）：void 0；
    是SSR && 设置SSRSetupState（false）；
    返回设置结果；
  }
  函数setupStatefulComponent（实例，isSSR）{
    var _a;
    const 组件 = 实例.类型;
    {
      如果（组件名称）{
        验证组件名称（组件.名称，实例.appContext.config）；
      }
      如果（组件.组件）{
        const 名称 = Object.keys(Component.components);
        对于（让 i = 0; i < names.length; i++）{
          验证组件名称（名称[i]，instance.appContext.config）；
        }
      }
      如果（组件指令）{
        const 名称 = Object.keys(Component.directives);
        对于（让 i = 0; i < names.length; i++）{
          验证指令名称（名称[i]）；
        }
      }
      如果 (Component.compilerOptions && isRuntimeOnly()) {
        警告$1(
          “仅当使用包含运行时编译器的 Vue 构建时才支持“compilerOptions”。由于您使用的是仅限运行时的构建，因此应通过构建工具配置传递选项。`
        （英文）：
      }
    }
    实例.accessCache = /* @__PURE__ */ Object.create(null);
    实例.proxy = 新的代理（实例.ctx，PublicInstanceProxyHandlers）；
    {
      暴露PropsOnRenderContext（实例）；
    }
    const { 设置 } = 组件；
    如果（设置）{
      暂停跟踪（）；
      const setupContext = 实例.setupContext = setup.length > 1 ?createSetupContext(实例) : null;
      const 重置 = 设置当前实例 (实例);
      const setupResult = callWithErrorHandling（
        设置，
        实例，
        0，
        [
          shallowReadonly（实例.props），
          设置上下文
        ]
      （英文）：
      const isAsyncSetup = isPromise(setupResult);
      重置跟踪（）；
      重置（）;
      如果 ((isAsyncSetup || 实例.sp) && !isAsyncWrapper (实例)) {
        标记AsyncBoundary（实例）；
      }
      如果（isAsyncSetup）{
        设置结果.然后（取消设置当前实例，取消设置当前实例）；
        如果 (isSSR) {
          返回 setupResult.then((resolvedResult) => {
            handleSetupResult（实例，resolvedResult，isSSR）；
          }).catch((e) => {
            处理错误（e，实例，0）；
          });
        } 别的 {
          实例.asyncDep = 设置结果；
          如果（！实例.suspense）{
            const name = (_a = Component.name) != null ? _a : "匿名";
            警告$1(
              “组件 <${name}>：setup 函数返回了一个承诺，但在父组件树中未找到 <Suspense> 边界。具有异步 setup() 的组件必须嵌套在 <Suspense> 中才能呈现。”
            （英文）：
          }
        }
      } 别的 {
        handleSetupResult（实例，setupResult，isSSR）；
      }
    } 别的 {
      完成组件设置（实例，isSSR）；
    }
  }
  函数 handleSetupResult(实例，setupResult，isSSR) {
    如果（isFunction（setupResult））{
      {
        实例.渲染=设置结果；
      }
    } 否则，如果 (isObject(setupResult)) {
      如果（isVNode（setupResult））{
        警告$1(
          `setup() 不应该直接返回 VNodes - 而是返回一个渲染函数。`
        （英文）：
      }
      {
        实例.devtoolsRawSetupState = setupResult;
      }
      实例.setupState = proxyRefs(setupResult);
      {
        暴露SetupStateOnRenderContext（实例）；
      }
    } 否则，如果 (setupResult !== void 0) {
      警告$1(
        `setup() 应返回一个对象。收到：${setupResult === null ? "null" : typeof setupResult}`
      （英文）：
    }
    完成组件设置（实例，isSSR）；
  }
  让编译$1；
  让 installWithProxy；
  函数registerRuntimeCompiler（_compile）{
    编译$1 = _编译;
    安装WithProxy = (i) => {
      如果（i.render._rc）{
        i.withProxy = 新 Proxy(i.ctx，RuntimeCompiledPublicInstanceProxyHandlers);
      }
    };
  }
  const isRuntimeOnly = () => !编译$1;
  函数 finishComponentSetup(实例，isSSR，skipOptions) {
    const 组件 = 实例.类型;
    如果（！实例.渲染）{
      如果（！isSSR && 编译$1 && ！Component.render）{
        const 模板 = 组件.模板 || resolveMergedOptions(实例).模板;
        如果（模板）{
          {
            开始测量（实例，`编译`）；
          }
          const { isCustomElement，compilerOptions } = instance.appContext.config;
          const { 分隔符， 编译器选项： componentCompilerOptions } = Component;
          const finalCompilerOptions = extend(
            延长（
              {
                是自定义元素，
                分隔符
              }，
              编译器选项
            ),
            组件编译器选项
          （英文）：
          组件.render = 编译$1(模板，finalCompilerOptions);
          {
            endMeasure（实例，`编译`）；
          }
        }
      }
      实例.render = 组件.render || NOOP;
      如果（安装WithProxy）{
        安装WithProxy（实例）；
      }
    }
    {
      const 重置 = 设置当前实例 (实例);
      暂停跟踪（）；
      尝试 {
        应用选项（实例）；
      } 最后 {
        重置跟踪（）；
        重置（）;
      }
    }
    如果 (!Component.render && instance.render === NOOP && !isSSR) {
      如果（！编译$1 && 组件.模板）{
        警告$1(
          `组件提供了模板选项，但是此版本的 Vue 不支持运行时编译。` + (` 请改用“vue.global.js”。` )
        （英文）：
      } 别的 {
        warn$1(`组件缺少模板或渲染函数：`，组件);
      }
    }
  }
  const attrsProxyHandlers = {
    获取（目标，键）{
      标记属性访问情况（）；
      跟踪（目标，“获取”，“”）；
      返回目标[key]；
    }，
    放（） {
      warn$1(`setupContext.attrs 是只读的。`);
      返回 false；
    }，
    删除属性() {
      warn$1(`setupContext.attrs 是只读的。`);
      返回 false；
    }
  }；
  函数 getSlotsProxy（实例）{
    返回新的代理（实例.slots，{
      获取（目标，键）{
        轨道（实例，“获取”，“$slots”）；
        返回目标[key]；
      }
    });
  }
  函数 createSetupContext（实例）{
    const 暴露 = (暴露) => {
      {
        如果（实例.暴露）{
          warn$1(`expose() 在每个 setup() 中只能调用一次。`);
        }
        如果（暴露！=空）{
          让 exposedType = typeof exposed;
          如果 (exposedType === “对象”) {
            如果 (isArray (暴露)) {
              暴露类型 = “数组”;
            } 否则，如果 (isRef(暴露)) {
              暴露类型 = “ref”;
            }
          }
          如果 (exposedType !== “对象”) {
            警告$1(
              `expose() 应该传递一个普通对象，接收 ${exposedType}。`
            （英文）：
          }
        }
      }
      实例.暴露 = 暴露 || {};
    };
    {
      让 attrsProxy；
      让 slotsProxy；
      返回 Object.freeze({
        获取属性() {
          返回 attrsProxy || (attrsProxy = new Proxy(instance.attrs, attrsProxyHandlers));
        }，
        获取插槽（）{
          返回 slotsProxy || (slotsProxy = getSlotsProxy(instance));
        }，
        获取发射（）{
          返回（事件，...参数）=> 实例.发出（事件，...参数）；
        }，
        暴露
      });
    }
  }
  函数 getComponentPublicInstance(实例) {
    如果（实例.暴露）{
      返回实例.exposeProxy || (实例.exposeProxy = 新代理(proxyRefs(markRaw(instance.exposed)), {
        获取（目标，键）{
          if (输入目标) {
            返回目标[key]；
          } else if (publicPropertiesMap 中的键) {
            返回 publicPropertiesMap[key](实例);
          }
        }，
        有（目标，键）{
          返回目标中的键 || publicPropertiesMap 中的键；
        }
      }））；
    } 别的 {
      返回实例.代理；
    }
  }
  const classifyRE = /(?:^|[-_])(\w)/g;
  const classify = (str) => str.replace(classifyRE，(c) => c.toUpperCase()).replace(/[-_]/g，“”);
  函数 getComponentName (Component，includeInferred = true) {
    返回 isFunction(Component) ? Component.displayName || Component.name : Component.name || includeInferred && Component.__name;
  }
  函数格式组件名称（实例，组​​件，isRoot = false）{
    让名称 = 获取组件名称 (组件);
    如果 (!name && 组件.__文件) {
      const match = Component.__file.match(/([^/\\]+)\.\w+$/);
      如果（匹配）{
        名称 = 匹配[1];
      }
    }
    如果（！名称&&实例&&实例.parent）{
      const inferFromRegistry = (注册表) => {
        for（注册表中的 const 键）{
          如果 (注册表 [键] === 组件) {
            返回键；
          }
        }
      };
      名称 = inferFromRegistry（
        实例.组件 || 实例.父.类型.组件
      ）|| inferFromRegistry（实例.appContext.components）；
    }
    返回名称？分类（名称）：isRoot？`App`：`Anonymous`；
  }
  函数 isClassComponent（值）{
    返回 isFunction(value) && 值中的“__vccOpts”；
  }

  const computed = (getterOrOptions，debugOptions) => {
    const c = 计算$1（getterOrOptions，debugOptions，isInSSRComponentSetup）；
    {
      获取当前实例
      如果（i && i.appContext.config.warnRecursiveComputed）{
        c._warnRecursive = true;
      }
    }
    返回c；
  };

  函数 h(类型，propsOrChildren，children) {
    const l = 参数.长度;
    如果 (l === 2) {
      如果（isObject（propsOrChildren）&&！isArray（propsOrChildren））{
        如果（isVNode（propsOrChildren））{
          返回 createVNode(type, null, [propsOrChildren]);
        }
        返回 createVNode(type, propsOrChildren);
      } 别的 {
        返回 createVNode(type, null, propsOrChildren);
      }
    } 别的 {
      如果 (l > 3) {
        子代 = Array.prototype.slice.call(参数， 2);
      } 否则，如果 (l === 3 && isVNode(children)) {
        孩子=[孩子]；
      }
      返回 createVNode(type, propsOrChildren, children);
    }
  }

  函数 initCustomFormatter() {
    如果 (typeof window === “undefined”) {
      返回;
    }
    const vueStyle = { 样式：“color:#3ba776” };
    const numberStyle = { 样式：“color:#1677ff” };
    const stringStyle = { 样式：“color：#f5222d” };
    const keywordStyle = { 样式：“color：#eb2f96” };
    const 格式化程序 = {
      __vue_custom_formatter: true，
      标题（对象）{
        如果 (!isObject(obj)) {
          返回空值；
        }
        如果（obj.__isVue）{
          返回 ["div", vueStyle, `VueInstance`];
        } 否则，如果 (isRef (obj)) {
          返回 [
            “div”，
            {}，
            [“span”，vueStyle，genRefFlag（obj）]，
            "<",
            // 避免调试器访问影响行为的值
            格式值(obj 中的“_value”？obj._value：obj)，
            `>`
          ]；
        } 否则，如果 (isReactive(obj)) {
          返回 [
            “div”，
            {}，
            ["span", vueStyle, isShallow(obj) ? "ShallowReactive" : "Reactive"],
            "<",
            格式值（对象），
            `>${isReadonly(obj) ? ` (只读)` : ``}`
          ]；
        } 否则，如果 (isReadonly (obj)) {
          返回 [
            “div”，
            {}，
            ["span", vueStyle, isShallow(obj) ? "ShallowReadonly" : "Readonly"],
            "<",
            格式值（对象），
            “>”
          ]；
        }
        返回空值；
      }，
      hasBody（obj）{
        返回 obj && obj.__isVue;
      }，
      主体（对象）{
        如果 (obj && obj.__isVue) {
          返回 [
            “div”，
            {}，
            ...格式实例（对象.$）
          ]；
        }
      }
    };
    函数格式实例（实例）{
      const 块 = [];
      如果（实例.类型.props && 实例.props）{
        块.推（createInstanceBlock（"props", toRaw（instance.props）））；
      }
      如果（实例.setupState！== EMPTY_OBJ）{
        块.推（createInstanceBlock（"setup", 实例.setupState））；
      }
      如果（实例.数据！== EMPTY_OBJ）{
        块.推送（createInstanceBlock（"数据", toRaw（实例.数据）））;
      }
      const computed = extractKeys（实例，“计算”）；
      如果（计算）{
        块.推送（createInstanceBlock（"计算", 计算））;
      }
      const injection = extractKeys（实例，“注入”）；
      如果（注入）{
        blocks.push(createInstanceBlock("注入", 注入));
      }
      块.推（[
        “div”，
        {}，
        [
          “跨度”，
          {
            样式：keywordStyle.style + ";opacity:0.66"
          }，
          “$（内部）：”
        ]，
        ["对象", { 对象：实例 }]
      ]);
      返回块；
    }
    函数 createInstanceBlock（类型，目标）{
      目标 = 延伸（{}，目标）；
      如果 (!Object.keys(target).length) {
        返回 ["span", {}];
      }
      返回 [
        “div”，
        { 样式：“行高：1.25em；边距：0.6em” }，
        [
          “div”，
          {
            样式：“颜色：#476582”
          }，
          类型
        ]，
        [
          “div”，
          {
            样式：“padding-left:1.25em”
          }，
          ...Object.keys（目标）。map（（key）=> {
            返回 [
              “div”，
              {}，
              ["span", keywordStyle, key + ": "],
              格式值（目标[键]，false）
            ]；
          }）
        ]
      ]；
    }
    函数格式值（v，asRaw = true）{
      如果 (typeof v === “number”) {
        返回 ["span", numberStyle, v];
      } 否则，如果 (typeof v === “string”) {
        返回 ["span", stringStyle, JSON.stringify(v)];
      } 否则，如果 (typeof v === “boolean”) {
        返回 ["span", keywordStyle, v];
      } 否则，如果 (isObject(v)) {
        返回 ["object", { object: asRaw ? toRaw(v) : v }];
      } 别的 {
        返回 ["span", stringStyle, String(v)];
      }
    }
    函数 extractKeys (实例，类型) {
      const Comp = 实例.类型;
      如果 (isFunction(Comp)) {
        返回;
      }
      const 提取 = {};
      对于（instance.ctx 中的 const 键）{
        如果 (isKeyOfType(Comp, 键, 类型)) {
          提取的[key] = 实例.ctx[key];
        }
      }
      返回提取的；
    }
    函数 isKeyOfType(Comp, key, type) {
      const opts = Comp[类型];
      如果 (isArray(opts) && opts.includes(key) || isObject(opts) && opts 中的键) {
        返回 true；
      }
      如果 (Comp.extends && isKeyOfType(Comp.extends, key, type)) {
        返回 true；
      }
      如果 (Comp.mixins && Comp.mixins.some((m) => isKeyOfType(m, key, type))) {
        返回 true；
      }
    }
    函数 genRefFlag(v) {
      如果（isShallow（v））{
        返回`ShallowRef`；
      }
      如果（v.效果）{
        返回 `ComputedRef`；
      }
      返回 `Ref`；
    }
    如果（window.devtoolsFormatters）{
      窗口.devtoolsFormatters.push（格式化程序）；
    } 别的 {
      window.devtoolsFormatters = [格式化程序];
    }
  }

  函数 withMemo（备忘录，渲染，缓存，索引）{
    const 缓存 = 缓存[索引];
    如果 (缓存 && isMemoSame(缓存，备忘录)) {
      返回缓存；
    }
    const ret = 渲染();
    ret.memo = memo.slice();
    ret.缓存索引 = 索引;
    返回缓存[index] = ret;
  }
  函数 isMemoSame（缓存，备忘录）{
    const prev = 缓存.memo;
    如果 (prev.length != memo.length) {
      返回 false；
    }
    对于（让 i = 0; i < prev.length; i++）{
      如果 (hasChanged(prev[i]，memo[i])) {
        返回 false；
      }
    }
    if (isBlockTreeEnabled > 0 && currentBlock) {
      currentBlock.推送（缓存）；
    }
    返回 true；
  }

  const 版本 = “3.5.13”;
  const 警告 = 警告$1；
  const 错误类型字符串 = 错误类型字符串$1 ;
  const devtools = devtools$1 ;
  常量设置DevtoolsHook = 设置DevtoolsHook $ 1;
  常量 ssrUtils = 空;
  const resolveFilter = null;
  const compatUtils = null;
  const DeprecationTypes = null;

  让策略 = void 0；
  const tt = typeof window !== “undefined” && window.trustedTypes;
  如果（tt）{
    尝试 {
      策略 = /* @__PURE__ */ tt.createPolicy("vue", {
        创建HTML：（val）=> val
      });
    } 捕获（e）{
      warn(`创建可信类型策略时出错：${e}`);
    }
  }
  const unsafeToTrustedHTML = policy ? (val) => policy.createHTML(val) : (val) => val;
  const svgNS = "http://www.w3.org/2000/svg";
  const mathmlNS = "http://www.w3.org/1998/Math/MathML";
  const doc = typeof document !== “undefined” ?document : null;
  const templateContainer = doc && /* @__PURE__ */ doc.createElement("模板");
  const 节点操作 = {
    插入：（子级，父级，锚点）=> {
      父级.insertBefore（子级，锚点 || null）；
    }，
    删除：（子）=> {
      const 父节点 = 子节点.parentNode;
      如果（父级）{
        父母.移除孩子（孩子）；
      }
    }，
    createElement：（标签，命名空间，是，道具）=> {
      const el = namespace === “svg” ?doc.createElementNS(svgNS, tag) : namespace === “mathml” ?doc.createElementNS(mathmlNS, tag) : 是 ?doc.createElement(tag, { is }) : doc.createElement(tag);
      如果（标签===“选择”&&道具&&道具.多个！= null）{
        el.setAttribute("多个", props.多个);
      }
      返回 el;
    }，
    创建文本：（文本）=> doc.createTextNode（文本），
    createComment：（文本）=> doc.createComment（文本），
    设置文本：（节点，文本）=> {
      节点.节点值 = 文本;
    }，
    设置元素文本： (el，文本) => {
      el.文本内容 = 文本;
    }，
    父节点：（节点）=> 节点.父节点，
    nextSibling：（节点）=>节点.nextSibling，
    querySelector：（选择器）=> doc.querySelector（选择器），
    设置ScopeId（el，id）{
      el.设置属性（id，“”）；
    }，
    // __不安全__
    // 原因：innerHTML。
    // 此处的静态内容只能来自已编译的模板。
    // 只要用户只使用受信任的模板，这是安全的。
    insertStaticContent（内容，父级，锚点，命名空间，开始，结束）{
      const before = anchor ? anchor.previousSibling : parent.lastChild;
      如果 (开始 && (开始 === 结束 || 开始.nextSibling)) {
        while (真) {
          父节点.insertBefore(start.cloneNode(true), 锚点);
          如果 (start === end || !(start = start.nextSibling)) 中断；
        }
      } 别的 {
        templateContainer.innerHTML = unsafeToTrustedHTML(
          命名空间 === “svg” ? `<svg>${content></svg>` : 命名空间 === “mathml” ? `<math>${content></math>` : 内容
        （英文）：
        const 模板 = templateContainer.content;
        如果（命名空间 ===“svg”||命名空间 ===“mathml”）{
          const 包装器 = 模板.firstChild;
          当（wrapper.firstChild）{
            模板.appendChild（wrapper.firstChild）；
          }
          模板.removeChild（包装器）；
        }
        父级.insertBefore（模板，锚点）；
      }
      返回 [
        // 第一的
        之前？之前.nextSibling：parent.firstChild，
        // 最后的
        锚点？anchor.previousSibling:parent.lastChild
      ]；
    }
  };

  const TRANSITION$1 = “过渡”;
  const ANIMATION = "动画";
  const vtcKey = 符号(“_vtc”);
  const DOMTransitionPropsValidators = {
    名称：字符串，
    类型：字符串，
    css：{
      类型：布尔值，
      默认值： true
    }，
    持续时间：[字符串，数字，对象]，
    输入类名：String，
    输入活动类：字符串，
    进入类：字符串，
    出现于类中: 字符串，
    出现活动类：字符串，
    出现于类：字符串，
    离开班级：字符串，
    离开活动类：字符串，
    离开班级：字符串
  };
  const TransitionPropsValidators = /* @__PURE__ */ 扩展（
    {}，
    BaseTransitionPropsValidators，
    DOMTransitionPropsValidators
  （英文）：
  const decorate$1 = （t）=> {
    t.displayName =“过渡”;
    t.props = TransitionPropsValidators;
    返回 t；
  };
  const Transition = /* @__PURE__ */ decorate$1(
    （props，{slots}）=> h（BaseTransition，resolveTransitionProps（props），slots）
  （英文）：
  const callHook = (hook, args = []) => {
    如果 (isArray (钩子)) {
      钩子.forEach((h2) => h2(...args));
    } 否则，如果（钩子）{
      钩子（……参数）；
    }
  };
  const hasExplicitCallback = (hook) => {
    返回 hook ？ isArray(hook) ？ hook.some((h2) => h2.length > 1) ： hook.length > 1 ： false；
  };
  函数 resolveTransitionProps (rawProps) {
    const baseProps = {};
    对于（rawProps 中的 const 键）{
      如果（！（DOMTransitionPropsValidators 中的键））{
        baseProps[键] = rawProps[键];
      }
    }
    如果 (rawProps.css===false) {
      返回 baseProps；
    }
    常量 {
      名称 = “v”,
      类型，
      期间，
      enterFromClass = `${name}-enter-from`,
      enterActiveClass = `${name}-enter-active`,
      enterToClass = `${name}-enter-to`,
      出现于班级 = 进入于班级，
      出现ActiveClass = 进入ActiveClass，
      出现在课堂上 = 进入课堂上，
      leaveFromClass = `${name}-leave-from`,
      leaveActiveClass = `${name}-leave-active`,
      leaveToClass = `${name}-leave-to`
    } = 原始属性；
    const 持续时间 = normalizeDuration(持续时间);
    const enterDuration = 持续时间&& 持续时间[0];
    const leaveDuration = 持续时间&& 持续时间[1];
    常量 {
      在进入之前，
      进入时，
      进入取消时，
      离开时，
      onLeaveCancelled，
      onBeforeAppear = onBeforeEnter，
      onAppear = onEnter，
      onAppearCancelled = onEnterCancelled
    } = 基础属性；
    const finishEnter = (el, isAppear, done, isCancelled) => {
      el._enterCancelled = 已取消；
      移除TransitionClass（el，isAppear？appearToClass：enterToClass）；
      移除TransitionClass(el，isAppear？appearActiveClass：enterActiveClass);
      完成 && 完成();
    };
    const finishLeave = (el, done) => {
      el._isLeaving = false;
      删除过渡类（el，leaveFromClass）；
      删除转换类（el，leaveToClass）；
      删除TransitionClass（el，leaveActiveClass）；
      完成 && 完成();
    };
    const makeEnterHook = (isAppear) => {
      返回 (el, done) => {
        const hook = isAppear ? onAppear : onEnter;
        const resolve = () => finishEnter(el, isAppear, done);
        callHook(hook，[el，resolve]);
        下一帧（（）=> {
          移除TransitionClass(el，isAppear？appearFromClass：enterFromClass);
          添加TransitionClass（el，isAppear？appearToClass：enterToClass）；
          如果 (!hasExplicitCallback (hook)) {
            当转换结束时（el，类型，enterDuration，resolve）；
          }
        });
      };
    };
    返回扩展（baseProps，{
      onBeforeEnter（el）{
        调用Hook（onBeforeEnter， [el]）；
        添加TransitionClass（el，enterFromClass）；
        addTransitionClass(el, EnterActiveClass);
      }，
      onBeforeAppear（el）{
        调用Hook（onBeforeAppear， [el]）；
        添加TransitionClass（el，appearFromClass）；
        添加TransitionClass（el，appearActiveClass）；
      }，
      onEnter：makeEnterHook（false），
      onAppear: makeEnterHook(true),
      onLeave（el，done）{
        el._isLeaving = true;
        const resolve = () => finishLeave(el, done);
        添加TransitionClass（el，离开类）；
        如果 (!el._enterCancelled) {
          强制重流（）；
          添加TransitionClass（el，离开ActiveClass）；
        } 别的 {
          添加TransitionClass（el，离开ActiveClass）；
          强制重流（）；
        }
        下一帧（（）=> {
          如果（！el._isLeaving）{
            返回;
          }
          删除过渡类（el，leaveFromClass）；
          添加TransitionClass（el，leaveToClass）；
          如果 (!hasExplicitCallback(onLeave)) {
            当转换结束时（el，类型，离开持续时间，解析）；
          }
        });
        callHook(onLeave， [el， resolve]);
      }，
      onEnterCancelled（el）{
        完成输入（el， false， void 0， true）；
        callHook(onEnterCancelled， [el]);
      }，
      onAppearCancelled（el）{
        完成输入（el， true， void 0， true）；
        调用Hook（onAppearCancelled，[el]）；
      }，
      onLeaveCancelled（el）{
        完成离开（el）；
        调用Hook(onLeaveCancelled， [el]);
      }
    });
  }
  函数 normalizeDuration（持续时间）{
    如果 (持续时间 == null) {
      返回空值；
    } 否则，如果 (isObject(持续时间)) {
      返回 [NumberOf(duration.enter), NumberOf(duration.leave)];
    } 别的 {
      const n = NumberOf(持续时间);
      返回[n，n]；
    }
  }
  函数 NumberOf(val) {
    const res = toNumber（val）;
    {
      assertNumber(res, "<transition> 明确持续时间");
    }
    返回 res；
  }
  函数 addTransitionClass(el，cls) {
    cls.拆分(/\s+/).forEach((c) => c && el.classList.添加(c));
    (el[vtcKey] || (el[vtcKey] = /* @__PURE__ */ new Set())).添加(cls);
  }
  函数 removeTransitionClass(el，cls) {
    cls.split(/\s+/).forEach((c) => c && el.classList.remove(c));
    const _vtc = el[vtcKey];
    如果（_vtc）{
      _vtc.删除（cls）；
      如果 (!_vtc.大小) {
        el[vtcKey] = 无效 0;
      }
    }
  }
  函数nextFrame（cb）{
    请求动画框架（（）=> {
      请求动画帧（cb）；
    });
  }
  让 endId = 0;
  函数 whenTransitionEnds（el，expectedType，explicitTimeout，resolve）{
    const id = el._endId = ++endId;
    常量resolveIfNotStale = () => {
      如果 (id === el._endId) {
        解决（）;
      }
    };
    如果 (explicitTimeout != null) {
      返回 setTimeout(resolveIfNotStale，explicitTimeout);
    }
    const { 类型， 超时， propCount } = getTransitionInfo(el， 预期类型);
    如果（！类型）{
      返回解析（）；
    }
    const endEvent = 类型 + "结束";
    让结束=0；
    const 结束 = () => {
      el.removeEventListener(endEvent, onEnd);
      解决如果不是过期的（）
    };
    const onEnd = （e）=> {
      如果 (e.target === el && ++ended >= propCount) {
        结尾（）;
      }
    };
    设置超时（（）=> {
      如果 (结束 < propCount) {
        结尾（）;
      }
    }, 超时 + 1);
    el.addEventListener(endEvent, onEnd);
  }
  函数 getTransitionInfo(el，expectedType) {
    const 样式 = 窗口.getComputedStyle(el);
    const getStyleProperties = (key) => (styles[key] || "").split(", ");
    const transitionDelays = getStyleProperties(`${TRANSITION$1}延迟`);
    const transitionDurations = getStyleProperties(`${TRANSITION$1}Duration`);
    const transitionTimeout = getTimeout(transitionDelays， transitionDurations);
    const animationDelays = getStyleProperties(`${ANIMATION}Delay`);
    const animationDurations = getStyleProperties(`${ANIMATION}Duration`);
    const animationTimeout = getTimeout(animationDelays，animationDurations);
    让类型 = 空；
    让超时 = 0；
    让 propCount = 0;
    如果 (预期类型 === TRANSITION$1) {
      如果 (transitionTimeout > 0) {
        类型=TRANSITION$1；
        超时=转换超时；
        propCount = transitionDurations.length;
      }
    } 否则，如果 (expectedType === 动画) {
      如果 (动画超时 > 0) {
        类型=动画；
        超时=动画超时；
        propCount = 动画持续时间.长度;
      }
    } 别的 {
      超时 = Math.max(transitionTimeout，animationTimeout);
      类型 = 超时 > 0 ? transitionTimeout > animationTimeout ? TRANSITION$1:动画: null;
      propCount = 类型？类型===TRANSITION$1？transitionDurations.length:animationDurations.length:0;
    }
    const hasTransform = 类型 === TRANSITION$1 && /\b(transform|all)(,|$)/.test(
      getStyleProperties(`${TRANSITION$1}属性`).toString()
    （英文）：
    返回 {
      类型，
      暂停，
      propCount，
      有变换
    };
  }
  函数 getTimeout (延迟，持续时间) {
    while (delays.length < durations.length) {
      延迟 = 延迟.concat（延迟）；
    }
    返回 Math.max(...durations.map((d, i) => toMs(d) + toMs(delays[i])));
  }
  函数 toMs(s) {
    如果（s ===“auto”）返回0；
    返回 Number(s.slice(0, -1).replace(",", ".")) * 1e3;
  }
  函数 forceReflow() {
    返回 document.body.offsetHeight;
  }

  函数patchClass（el，值，isSVG）{
    const transitionClasses = el[vtcKey];
    如果（转换类）{
      值 = （值 ? [值，...transitionClasses] : [...transitionClasses]）.join（“ ”）;
    }
    如果 (值 == null) {
      el.removeAttribute(“类”);
    } 否则，如果 (isSVG) {
      el.setAttribute("类", 值);
    } 别的 {
      el.类名 = 值;
    }
  }

  const vShowOriginalDisplay = 符号(“_vod”);
  const vShowHidden = 符号("_vsh");
  const vShow = {
    beforeMount（el，{值}，{过渡}）{
      el[vShowOriginalDisplay] = el.style.display ===“无”？ "" : el.style.display;
      如果（转换 && 值）{
        转换.beforeEnter（el）；
      } 别的 {
        设置显示（el，值）；
      }
    }，
    已安装（el，{值}，{转换}）{
      如果（转换 && 值）{
        转换.进入(el);
      }
    }，
    更新（el，{值，旧值}，{过渡}）{
      如果（！value === ！oldValue）返回；
      如果（过渡）{
        如果（值）{
          转换.beforeEnter（el）；
          设置显示（el，true）；
          转换.进入(el);
        } 别的 {
          过渡.离开（el，（）=> {
            设置显示（el，false）；
          });
        }
      } 别的 {
        设置显示（el，值）；
      }
    }，
    beforeUnmount(el，{ 值 }) {
      设置显示（el，值）；
    }
  };
  {
    vShow.name = “显示”;
  }
  函数 setDisplay（el，值）{
    el.style.display = 值 ? el[vShowOriginalDisplay] : "无";
    el[vShowHidden] = !值;
  }

  const CSS_VAR_TEXT = 符号("CSS_VAR_TEXT" );
  函数 useCssVars(getter) {
    const 实例 = 获取当前实例 ();
    如果（！实例）{
      warn(`在没有当前活动组件实例的情况下调用 useCssVars。`);
      返回;
    }
    const updateTeleports = instance.ut = (vars = getter(instance.proxy)) => {
      数组.from(
        document.querySelectorAll(`[data-v-owner="${instance.uid}"]`)
      ).forEach((节点) => setVarsOnNode(节点，变量));
    };
    {
      实例.getCssVars = () => getter(实例.proxy);
    }
    const setVars = () => {
      const vars = getter(实例.代理);
      如果（实例.ce）{
        setVarsOnNode(instance.ce, vars);
      } 别的 {
        设置VarsOnVNode（实例.subTree，vars）；
      }
      更新电信（变量）；
    };
    onBeforeUpdate(() => {
      队列PostFlushCb（设置变量）；
    });
    onMounted（（）=> {
      监视（setVars，NOOP，{flush：“post”}）；
      const ob = 新的 MutationObserver(setVars);
      ob.观察（实例.subTree.el.parentNode， { childList: true }）；
      onUnmounted（（）=> ob.disconnect（））;
    });
  }
  函数 setVarsOnVNode(vnode, vars) {
    如果（vnode.shapeFlag & 128）{
      const suspense = vnode.suspense;
      vnode = suspense.activeBranch;
      如果 (suspense.pendingBranch && !suspense.isHydrating) {
        suspense.effects.push(() => {
          setVarsOnVNode(suspense.activeBranch, vars);
        });
      }
    }
    while (vnode.component) {
      vnode = vnode.component.子树；
    }
    if (vnode.shapeFlag & 1 && vnode.el) {
      setVarsOnNode(vnode.el, vars);
    } 否则，如果 (vnode.type === 片段) {
      vnode.children.forEach((c) => setVarsOnVNode(c，vars));
    } 否则，如果 (vnode.type === 静态) {
      让 { el，anchor } = vnode;
      当 (el) {
        设置VarsOnNode（el，vars）；
        如果（el===锚点）中断；
        el = el.nextSibling;
      }
    }
  }
  函数 setVarsOnNode(el，vars) {
    如果 (el.nodeType === 1) {
      const 样式 = el.style;
      让cssText =“”;
      对于（vars 中的 const 键）{
        style.setProperty(`--${key}`，vars[key]);
        cssText += `--${key}: ${vars[key]};`;
      }
      样式[CSS_VAR_TEXT] = cssText;
    }
  }

  const displayRE = /(^|;)\s*display\s*:/;
  函数 patchStyle(el，prev，next) {
    const 样式 = el.style;
    const isCssString = isString（下一个）；
    让 hasControlledDisplay = false;
    如果（下一个 && ！isCssString）{
      如果（上一个）{
        如果 (!isString(prev)) {
          for (prev 中的 const 键) {
            如果 (下一个 [键] == null) {
              设置样式（风格，键，“”）；
            }
          }
        } 别的 {
          对于（const prevStyle of prev.split（“;”））{
            const key = prevStyle.slice(0， prevStyle.indexOf(“:”)).trim();
            如果 (下一个 [键] == null) {
              设置样式（风格，键，“”）；
            }
          }
        }
      }
      for（const 键在下一个）{
        如果 (键 === “显示”) {
          有控制显示 = 真；
        }
        设置样式（样式，键，下一个[键]）；
      }
    } 别的 {
      如果 (isCssString) {
        如果（上一个！==下一个）{
          const cssVarText = 样式[CSS_VAR_TEXT];
          如果（cssVarText）{
            下一个+=“；”+cssVarText；
          }
          样式.css文本 = 下一步;
          hasControlledDisplay = displayRE.测试（下一个）；
        }
      } 否则，如果 (上一个) {
        el.removeAttribute(“样式”);
      }
    }
    如果（vShowOriginalDisplay 在 el 中）{
      el[vShowOriginalDisplay] = hasControlledDisplay ? style.display : “”;
      如果 (el[vShowHidden]) {
        样式.显示 = “无”;
      }
    }
  }
  const 分号RE = /[^\\];\s*$/;
  const importantRE = /\s*!important$/;
  函数 setStyle(样式，名称，值) {
    如果 (isArray(val)) {
      val.forEach((v) => setStyle(样式，名称，v));
    } 别的 {
      如果 (val == null) val = "";
      {
        如果 (分号RE.test(val)) {
          警告（
            `'${name}' 样式值末尾出现意外分号：'${val}'`
          （英文）：
        }
      }
      如果 (name.startsWith("--")) {
        样式.setProperty（名称，val）；
      } 别的 {
        const prefixed = autoPrefix(style，name);
        如果（importantRE.test（val））{
          样式.setProperty(
            连字符（前缀），
            val.replace（importantRE，“”），
            “重要的”
          （英文）：
        } 别的 {
          样式[前缀] = val;
        }
      }
    }
  }
  const 前缀 = ["Webkit", "Moz", "ms"];
  const 前缀缓存 = {};
  函数 autoPrefix (style，rawName) {
    const cached = prefixCache[rawName];
    如果（缓存）{
      返回缓存；
    }
    让名称 = camelize（rawName）；
    if (name !== “filter” && 样式中的名称) {
      返回前缀缓存[rawName] = 名称;
    }
    名称 = 大写（名称）；
    对于（让 i = 0；i <前缀.长度；i++）{
      const prefixed = prefixes[i] + name;
      if（样式前缀）{
        返回 prefixCache[rawName] = prefixed;
      }
    }
    返回原始名称；
  }

  const xlinkNS = "http://www.w3.org/1999/xlink";
  函数 patchAttr(el、key、value、isSVG、instance、isBoolean = isSpecialBooleanAttr(key)) {
    如果（isSVG && key.startsWith（“xlink：”））{
      如果 (值 == null) {
        el.removeAttributeNS(xlinkNS， key.slice(6， key.length));
      } 别的 {
        el.设置属性NS(xlinkNS，键，值)；
      }
    } 别的 {
      如果 (值 == null || isBoolean && !includeBooleanAttr(值)) {
        el.removeAttribute（键）；
      } 别的 {
        el.设置属性（
          钥匙，
          是布尔值吗？“”：是符号（值）吗？字符串（值）：值
        （英文）：
      }
    }
  }

  函数 patchDOMProp(el， key， value， parentComponent， attrName) {
    如果 (键 === “innerHTML” || 键 === “textContent”) {
      如果（值！= null）{
        el[key] = key === “innerHTML” ?unsafeToTrustedHTML (value) : value;
      }
      返回;
    }
    const 标签 = el.标签名称;
    if (key === "value" && tag !== "PROGRESS" && // 自定义元素可以在内部使用 _value
    !标签.包括(“-”)）{
      const oldValue = tag === “OPTION” ? el.getAttribute(“value”) || “” : el.value;
      const newValue = value == null ? (
        // #11647: 对于 null 和 undefined，应将值设置为空字符串，
        // 但 <input type="checkbox"> 应该设置为“on”。
        el.type ===“复选框”？“开”：“”
      ): 字符串（值）；
      如果 (oldValue !== newValue || !(el 中的“_value”)) {
        el.值 = 新值;
      }
      如果 (值 == null) {
        el.removeAttribute（键）；
      }
      el._value = 值;
      返回;
    }
    让 needRemove = false;
    如果（值===“”||值==null）{
      const 类型 = el[key] 的类型；
      如果（类型===“布尔”）{
        值 = 包含布尔属性 (值)；
      } 否则，如果 (值 == null && 类型 === “string”) {
        值=“”；
        需要删除 = true;
      } 否则，如果 (类型 === “数字”) {
        值=0；
        需要删除 = true;
      }
    }
    尝试 {
      el[键] = 值;
    } 捕获（e）{
      如果（！需要删除）{
        警告（
          `在 <${tag.toLowerCase()}> 上设置属性“${key}”失败：值 ${value} 无效。`，
          埃
        （英文）：
      }
    }
    需要删除 && el.removeAttribute（attrName || key）；
  }

  函数 addEventListener（el，事件，处理程序，选项）{
    el.addEventListener（事件，处理程序，选项）；
  }
  函数 removeEventListener（el，事件，处理程序，选项）{
    el.removeEventListener（事件，处理程序，选项）；
  }
  const veiKey = Symbol("_vei");
  函数 patchEvent(el，rawName，prevValue，nextValue，instance = null) {
    const 调用者 = el[veiKey] || (el[veiKey] = {});
    constexistingInvoker =invokers[rawName];
    如果 (nextValue && 现有调用者) {
      现有的Invoker.value = sanitizeEventValue(nextValue，rawName)；
    } 别的 {
      const [名称，选项] = parseName(rawName);
      如果（下一个值）{
        constinvoker =invokers[rawName] = createInvoker(
          sanitizeEventValue（nextValue，rawName），
          实例
        （英文）：
        添加事件监听器（el，名称，调用者，选项）；
      } 否则，如果 (现有调用者) {
        删除事件监听器（el，name，existingInvoker，options）；
        调用者[rawName] = void 0;
      }
    }
  }
  const optionsModifierRE = /(?:Once|Passive|Capture)$/;
  函数解析名称（名称）{
    让选项；
    如果 (optionsModifierRE.test(name)) {
      选项={}；
      让 m；
      当（m = name.match（optionsModifierRE））{
        名称 = 名称.切片（0，名称.长度 - m[0].长度）；
        选项[m[0].toLowerCase()] = true;
      }
    }
    const 事件 = name[2] === ":" ? name.slice(3) : 连字符(name.slice(2));
    返回[事件，选项]；
  }
  让cachedNow = 0;
  const p = /* @__PURE__ */ Promise.resolve();
  const getNow = () => cachedNow || (p.then(() => cachedNow = 0), cachedNow = Date.now());
  函数 createInvoker（initialValue，实例）{
    const 调用者 = （e）=> {
      如果（！e._vts）{
        e._vts = 日期.now();
      } 否则，如果 (e._vts <= invoker.attached) {
        返回;
      }
      调用异步错误处理（
        patchStopImmediatePropagation（e，invoker.value），
        实例，
        5、
        [e]
      （英文）：
    };
    调用者.值 = 初始值;
    调用者.attached = getNow();
    返回调用者；
  }
  函数 sanitizeEventValue (值， propName) {
    if (isFunction(value) || isArray(value)) {
      返回值；
    }
    警告（
      `将错误的类型作为事件处理程序传递给 ${propName} - 您是否忘记了 prop 前面的 @ 或 :？
预期函数或函数数组，收到类型${typeof value}。`
    （英文）：
    返回 NOOP；
  }
  函数patchStopImmediatePropagation（e，值）{
    如果 (isArray (值)) {
      const originalStop = e.stopImmediatePropagation;
      e.stopImmediatePropagation = () => {
        原始停止.调用（e）；
        e._stopped = true;
      };
      返回值.map（
        （fn）=>（e2）=>！e2._stopped && fn && fn（e2）
      （英文）：
    } 别的 {
      返回值；
    }
  }

  const isNativeOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && // 小写字母
  密钥.charCodeAt(2) > 96 && 密钥.charCodeAt(2) < 123;
  const patchProp = (el, key, prevValue, nextValue, namespace, parentComponent) => {
    const isSVG = namespace === “svg”;
    如果 (键 === “类”) {
      补丁类（el，nextValue，isSVG）；
    }否则，如果（键===“样式”）{
      patchStyle(el, prevValue, nextValue);
    } 否则，如果 (isOn(key)) {
      如果 (!isModelListener(key)) {
        patchEvent(el， key， prevValue， nextValue， parentComponent);
      }
    } 否则，如果 (key[0] === "." ? (key = key.slice(1), true) : key[0] === "^" ? (key = key.slice(1), false) : shouldSetAsProp(el, key, nextValue, isSVG)) {
      patchDOMProp(el, key, nextValue);
      如果 (!el.tagName.includes("-") && (key === "value" || key === "checked" || key === "selected")) {
        patchAttr(el，key，nextValue，isSVG，parentComponent，key！==“值”);
      }
    }否则，如果（
      // #11081 强制设置可能的异步自定义元素的 props
      el._isVueCE && (/[AZ]/.test(key) || !isString(nextValue))
    ）{
      patchDOMProp(el， camelize(key)， nextValue， parentComponent， key);
    } 别的 {
      如果 (键 === “真值”) {
        el._trueValue = 下一个值;
      } 否则，如果 (键 === “false 值”) {
        el._falseValue = nextValue;
      }
      patchAttr（el，key，nextValue，isSVG）；
    }
  };
  函数 shouldSetAsProp(el，key，value，isSVG) {
    如果（isSVG）{
      如果 (键 === “innerHTML” || 键 === “textContent”) {
        返回 true；
      }
      如果 (键入 el && isNativeOn(key) && isFunction(value)) {
        返回 true；
      }
      返回 false；
    }
    如果 (key === “拼写检查” || key === “可拖动” || key === “翻译”) {
      返回 false；
    }
    如果 (键 === “表格”) {
      返回 false；
    }
    如果 (key === “列表” && el.tagName === “输入”) {
      返回 false；
    }
    如果 (key === “type” && el.tagName === “TEXTAREA”) {
      返回 false；
    }
    如果（键===“宽度”||键===“高度”）{
      const 标签 = el.标签名称;
      if (标签 === “IMG” || 标签 === “VIDEO” || 标签 === “CANVAS” || 标签 === “SOURCE”) {
        返回 false；
      }
    }
    如果（isNativeOn（键）&& isString（值））{
      返回 false；
    }
    el 中的返回键；
  }

  const 移除 = {};
  /*!#__无副作用__*/
  //@__无副作用__
  函数 defineCustomElement（选项，extraOptions，_createApp）{
    const Comp = defineComponent(选项， extraOptions);
    如果（isPlainObject（Comp））扩展（Comp，extraOptions）；
    类 VueCustomElement 扩展了 VueElement {
      构造函数（initialProps）{
        超级（Comp，initialProps，_createApp）；
      }
    }
    VueCustomElement.def = 计算;
    返回 VueCustomElement；
  }
  /*!#__无副作用__*/
  const defineSSRCustomElement = /* @__NO_SIDE_EFFECTS__ */ (options, extraOptions) => {
    返回/*@__PURE__*/defineCustomElement（options，extraOptions，createSSRApp）；
  };
  const BaseClass = typeof HTMLElement !== “undefined” ? HTMLElement : class {
  };
  类 VueElement 扩展了 BaseClass {
    构造函数（_def，_props = {}，_createApp = createApp）{
      极好的（）;
      这个。_def = _def;
      这个._props = _props;
      这个。_createApp = _createApp;
      这个。_isVueCE = true;
      /**
       * @内部的
       */
      这个._instance = 空;
      /**
       * @内部的
       */
      这个._app = 空;
      /**
       * @内部的
       */
      这个._nonce = 这个._def.nonce;
      这个._connected = false;
      这个。_resolved = false;
      这个._numberProps = 空;
      this._styleChildren = /* @__PURE__ */ new WeakSet();
      这个._ob = 空;
      如果 (this.shadowRoot && _createApp !== createApp) {
        这个。_root = 这个。shadowRoot；
      } 别的 {
        如果（这个.shadowRoot）{
          警告（
            “自定义元素具有预渲染的声明性影子根，但未定义为可水合。使用 \`defineSSRCustomElement\`。”
          （英文）：
        }
        如果 (_def.shadowRoot !== false) {
          这个。attachShadow（{模式：“打开”}）;
          这个。_root = 这个。shadowRoot；
        } 别的 {
          这个._root = 这个;
        }
      }
      如果 (!this._def.__asyncLoader) {
        这个。_resolveProps（这个。_def）；
      }
    }
    已连接回调() {
      如果（！this.isConnected）返回；
      如果 (!this.shadowRoot) {
        这个._parseSlots（）;
      }
      这个._connected = true;
      让父母=这个；
      while (parent = parent && (parent.parentNode || parent.host)) {
        如果 (VueElement 的父实例) {
          这个。_parent = 父母；
          休息;
        }
      }
      如果（！这个._instance）{
        如果（this._resolved）{
          这个._setParent()；
          这个._update（）；
        } 别的 {
          如果 (父母 && 父母._pendingResolve) {
            这个。_pendingResolve = 父级。_pendingResolve.then（（）=> {
              这个。_pendingResolve = void 0;
              这个._resolveDef（）；
            });
          } 别的 {
            这个._resolveDef（）；
          }
        }
      }
    }
    _setParent(父级 = this._parent) {
      如果（父级）{
        这个._instance.parent = 父母._instance;
        这个._instance.提供 = 父级._instance.提供;
      }
    }
    断开连接回调() {
      这个._connected = false;
      nextTick(() => {
        如果（！此._connected）{
          如果（这个._ob）{
            这个._ob.断开连接（）；
            这个._ob = 空;
          }
          这个._app && 这个._app.unmount();
          如果（this._instance）this._instance.ce = void 0;
          这个._app = 这个._instance = null;
        }
      });
    }
    /**
     * 解析内部组件定义（处理可能的异步组件）
     */
    _resolveDef() {
      如果（this._pendingResolve）{
        返回;
      }
      对于（让 i = 0；i < this.attributes.length；i++）{
        这个._setAttr（这个.attributes[i].name）；
      }
      this._ob = new MutationObserver((mutations) => {
        对于（突变的 const m）{
          这个._setAttr（m.属性名称）；
        }
      });
      this._ob.observe（this，{属性：true}）；
      const resolve = (def, isAsync = false) => {
        这个._resolved = true;
        这个。_pendingResolve = void 0;
        const { props，样式 } = def;
        让numberProps；
        如果（道具&&！isArray（道具））{
          对于（props中的const键）{
            const opt = props[key];
            如果（opt === Number || opt && opt.type === Number）{
              如果（输入 this._props）{
                这个。_props [key] = toNumber（这个。_props [key]）；
              }
              (numberProps || (numberProps = /* @__PURE__ */ Object.create(null)))[camelize(key)] = true;
            }
          }
        }
        这个。_numberProps = numberProps;
        如果（isAsync）{
          这个._resolveProps（def）；
        }
        如果（这个.shadowRoot）{
          这个._applyStyles（样式）；
        } 否则，如果（样式）{
          警告（
            “使用 shadowRoot: false 时不支持自定义元素样式注入”
          （英文）：
        }
        这个._mount（def）；
      };
      const asyncDef = this._def.__asyncLoader;
      如果（异步定义）{
        this._pendingResolve = asyncDef().then(
          （def）=> 解析（this._def = def，true）
        （英文）：
      } 别的 {
        解决（this._def）；
      }
    }
    _mount（def）{
      如果（！def.名称）{
        def.name = “VueElement”;
      }
      这个._app = 这个._createApp（def）;
      如果（def.configureApp）{
        def.configureApp（这个._app）；
      }
      这个._app._ceVNode = 这个._createVNode();
      这个._app.mount（这个._root）；
      const 暴露 = this._instance && this._instance.exposed;
      如果（！暴露）返回；
      对于（暴露中的 const 键）{
        如果 (!hasOwn(this, key)) {
          Object.defineProperty（this，键，{
            // 解开 ref 以与公共实例行为保持一致
            获取：（）=> unref（exposed[key]）
          });
        } 别的 {
          warn(`自定义元素上已存在公开属性“${key}”。`);
        }
      }
    }
    _resolveProps（def）{
      const { props } = def;
      const declaredPropKeys = isArray(props) ? props : Object.keys(props || {});
      对于（Object.keys（this）的 const 键）{
        如果 (key[0] !== "_" && declaredPropKeys.includes(key)) {
          这个。_setProp（键，这个[键]）；
        }
      }
      对于（ declaredPropKeys.map(camelize) 的 const 键）{
        Object.defineProperty（this，键，{
          得到（） {
            返回这个。_getProp（key）；
          }，
          设置（val）{
            这个._setProp（key，val，true，true）；
          }
        });
      }
    }
    _setAttr（键）{
      如果（key.startsWith（“data-v-”））返回；
      var key = new KeyAttribute(key);
      让值 = 有？this.getAttribute（key）：删除；
      constcamelKey=camelize(key);
      如果 (有 && this._numberProps && this._numberProps[camelKey]) {
        值 = 到数字 (值);
      }
      这个。_setProp（camelKey，值，false，true）；
    }
    /**
     * @内部的
     */
    _getProp（键）{
      返回 this._props[key];
    }
    /**
     * @内部的
     */
    _setProp（key，val，shouldReflect = true，shouldUpdate = false）{
      如果 (val !== this._props[key]) {
        如果（val === 删除）{
          删除 this._props[key];
        } 别的 {
          这个._props [key] = val;
          如果 (key === “key” && this._app) {
            这个._app._ceVNode.key = val;
          }
        }
        如果（应该更新 && this._instance）{
          这个._update（）；
        }
        如果（应该反映）{
          const ob = this._ob;
          ob && ob.断开连接();
          如果 (val === true) {
            this.setAttribute（连字符（键），“”）；
          } 否则，如果 (typeof val === “string” || typeof val === “number”) {
            this.setAttribute（连字符（key），val +“”）；
          } 否则，如果 (!val) {
            这个.removeAttribute（连字符（键））;
          }
          ob && ob.观察（this，{ 属性： true }）；
        }
      }
    }
    _更新（） {
      渲染（this._createVNode（），this._root）；
    }
    _createVNode() {
      const baseProps = {};
      如果 (!this.shadowRoot) {
        baseProps.onVnodeMounted = baseProps.onVnodeUpdated = this._renderSlots.bind(this);
      }
      const vnode = createVNode(this._def， 扩展(baseProps， this._props));
      如果（！这个._instance）{
        vnode.ce = (实例) => {
          这个._instance = 实例；
          实例.ce = 这个；
          实例.isCE = true;
          {
            实例.ceReload = (newStyles) => {
              如果（这个._styles）{
                这个._styles.forEach((s) => 这个._root.removeChild(s));
                这个._styles.length = 0;
              }
              这个。_applyStyles（newStyles）；
              这个._instance = 空;
              这个._update（）；
            };
          }
          const dispatch = (事件，参数) => {
            这.dispatchEvent（
              新的自定义事件（
                事件，
                isPlainObject(args[0]) ? 扩展({ 详细信息： args }，args[0]) : { 详细信息： args }
              ）
            （英文）：
          };
          实例.emit = (事件，...参数) => {
            调度（事件，参数）；
            如果（连字符（事件）！==事件）{
              调度（连字符（事件），参数）；
            }
          };
          这个._setParent()；
        };
      }
      返回vnode；
    }
    _applyStyles（样式，所有者）{
      如果（！styles）返回；
      如果（所有者）{
        如果 (所有者 === this._def || this._styleChildren.has(所有者)) {
          返回;
        }
        这个._styleChildren.添加（所有者）；
      }
      const nonce = this._nonce;
      对于（让 i = style.length - 1; i >= 0; i--）{
        const s = document.createElement("样式");
        如果（nonce）s.setAttribute（“nonce”，nonce）；
        s.文本内容 = 样式[i];
        这个.shadowRoot.prepend(s);
        {
          如果（所有者）{
            如果 (所有者.__hmrId) {
              如果（！this._childStyles）this._childStyles = /* @__PURE__ */ new Map();
              让 entry = this._childStyles.get(owner.__hmrId);
              如果（！条目）{
                这个._childStyles.设置（所有者.__hmrId，entry = []）；
              }
              入口.推(s);
            }
          } 别的 {
            （this._styles ||（this._styles = []））.推（s）；
          }
        }
      }
    }
    /**
     * 仅当 shadowRoot 为 false 时调用
     */
    _parseSlots() {
      const 插槽 = this._slots = {};
      让 n；
      当（n = this.firstChild）{
        const slotName = n.nodeType === 1 && n.getAttribute("slot") || “默认”;
        (插槽[插槽名称] || (插槽[插槽名称] = [])).推(n);
        这个.removeChild（n）；
      }
    }
    /**
     * 仅当 shadowRoot 为 false 时调用
     */
    _renderSlots() {
      const 出口 = （this._teleportTarget || this）.querySelectorAll（“slot”）；
      const scopeId = this._instance.type.__scopeId;
      对于（让 i = 0; i < outlets.length; i++）{
        const o = 出口[i];
        const slotName = o.getAttribute("名称") || "默认";
        const 内容 = this._slots[slotName];
        const 父节点 = o.parentNode;
        如果（内容）{
          for (const n 的内容) {
            如果 (scopeId && n.nodeType === 1) {
              const id = scopeId + “-s”;
              复制代码
              n.设置属性（id，“”）；
              讓孩子；
              while (child = walker.nextNode()) {
                子对象.setAttribute（id， “”）；
              }
            }
            父级.insertBefore（n，o）；
          }
        } 别的 {
          当 (o.firstChild) 父级.insertBefore(o.firstChild，o) 时；
        }
        父级.移除子级（o）；
      }
    }
    /**
     * @内部的
     */
    _injectChildStyle（组合）{
      这个._applyStyles（comp.styles，comp）；
    }
    /**
     * @内部的
     */
    _removeChildStyle（comp）{
      {
        这个._styleChildren.删除（comp）；
        如果（this._childStyles && comp.__hmrId）{
          const oldStyles = this._childStyles.get(comp.__hmrId);
          如果（oldStyles）{
            oldStyles.forEach((s) => this._root.removeChild(s));
            旧样式.长度 = 0;
          }
        }
      }
    }
  }
  函数 useHost(调用者) {
    const 实例 = 获取当前实例 ();
    const el = 实例 && 实例.ce;
    如果（el）{
      返回 el;
    } 别的 {
      如果（！实例）{
        警告（
          `${caller || "useHost"} 在没有活动组件实例的情况下被调用。`
        （英文）：
      } 别的 {
        警告（
          `${caller || "useHost"} 只能在通过 defineCustomElement 定义的组件中使用。`
        （英文）：
      }
    }
    返回空值；
  }
  函数 useShadowRoot() {
    const el = useHost("useShadowRoot") ;
    返回 el && el.shadowRoot;
  }

  函数 useCssModule(name = "$style") {
    {
      {
        warn(`全局构建不支持useCssModule()。`);
      }
      返回 EMPTY_OBJ；
    }
  }

  const positionMap = /* @__PURE__ */ new WeakMap();
  const newPositionMap = /* @__PURE__ */ new WeakMap();
  const moveCbKey = Symbol("_moveCb");
  const enterCbKey = Symbol("_enterCb");
  const 装饰 = （t）=> {
    删除 t.props.mode；
    返回 t；
  };
  const TransitionGroupImpl = /* @__PURE__ */ decorate({
    名称：“TransitionGroup”，
    道具：/* @__PURE__ */ 扩展（{}，TransitionPropsValidators，{
      标签：字符串，
      移动类别：字符串
    }),
    设置（道具，{ 插槽 }）{
      const 实例 = 获取当前实例 ();
      const 状态 = useTransitionState();
      让 prevChildren；
      让孩子们；
      更新（（）=> {
        如果 (!prevChildren.length) {
          返回;
        }
        const moveClass = props.moveClass || `${props.name || "v"}-move`;
        如果 (!hasCSSTransform(
          prevChildren[0].el，
          实例.vnode.el，
          移动类
        ））{
          返回;
        }
        prevChildren.forEach（callPendingCbs）；
        prevChildren.forEach(记录位置);
        const removedChildren = prevChildren.filter(applyTranslation);
        强制重流（）；
        已移动的儿童。forEach((c) => {
          const el = c.el;
          const 样式 = el.style;
          添加TransitionClass（el，moveClass）；
          样式.transform = 样式.webkitTransform = 样式.transitionDuration =“”;
          const cb = el[moveCbKey] = (e) => {
            如果 (e && e.target !== el) {
              返回;
            }
            如果（！e || /transform$/.test（e.propertyName））{
              el.removeEventListener("transitionend", cb);
              el[moveCbKey] = 空;
              删除过渡类（el，moveClass）；
            }
          };
          el.addEventListener("transitionend", cb);
        });
      });
      返回 () => {
        const rawProps = toRaw(props);
        const cssTransitionProps = resolveTransitionProps(rawProps);
        让 tag = rawProps.tag || 片段；
        上一个孩子 = [];
        如果（孩子）{
          对于（让 i = 0; i < children.length; i++）{
            const 孩子 = 孩子[i];
            如果（child.el && child.el 元素实例）{
              prevChildren.push(child);
              设置TransitionHooks（
                孩子，
                resolveTransitionHooks（
                  孩子，
                  cssTransitionProps，
                  状态，
                  实例
                ）
              （英文）：
              位置图.设置（
                孩子，
                子级.el.getBoundingClientRect()
              （英文）：
            }
          }
        }
        子级 = 插槽。默认？getTransitionRawChildren（插槽。默认（））：[]；
        对于（让 i = 0; i < children.length; i++）{
          const 孩子 = 孩子[i];
          如果 (child.key != null) {
            设置TransitionHooks（
              孩子，
              resolveTransitionHooks（子级，cssTransitionProps，状态，实例）
            （英文）：
          } 否则，如果 (child.type !== Text) {
            warn(`<TransitionGroup> 子项必须是键控的。`);
          }
        }
        返回 createVNode(tag, null, children);
      };
    }
  });
  const TransitionGroup = TransitionGroupImpl;
  函数调用PendingCbs（c）{
    const el = c.el;
    如果 (el[moveCbKey]) {
      el[moveCbKey]();
    }
    如果 (el[enterCbKey]) {
      el[输入CbKey]();
    }
  }
  函数记录位置（c）{
    newPositionMap.设置（c，c.el.getBoundingClientRect（））;
  }
  函数applyTranslation（c）{
    const oldPos = positionMap.get(c);
    复制代码
    const dx = 旧Pos.left - 新Pos.left;
    const dy = oldPos.top - newPos.top;
    如果 (dx || dy) {
      复制代码
      s.transform = s.webkitTransform = `翻译（${dx}px，${dy}px）`;
      s.transitionDuration = "0s";
      返回c；
    }
  }
  函数 hasCSSTransform(el， root，moveClass) {
    const 克隆 = el.cloneNode();
    const _vtc = el[vtcKey];
    如果（_vtc）{
      _vtc.forEach((cls) => {
        cls.split(/\s+/).forEach((c) => c && clone.classList.remove(c));
      });
    }
    moveClass.split(/\s+/).forEach((c) => c && clone.classList.add(c));
    克隆.style.display =“无”;
    const 容器 = root.nodeType === 1 ?根：根.parentNode；
    容器.appendChild（克隆）；
    复制代码
    容器.removeChild（克隆）；
    返回 hasTransform；
  }

  const getModelAssigner = （vnode） => {
    const fn = vnode.props["onUpdate:modelValue"] || false;
    返回 isArray(fn) ？ (值) => invokeArrayFns(fn, 值) : fn;
  };
  函数 onCompositionStart(e) {
    目标.组合 = true;
  }
  函数 onCompositionEnd(e) {
    const 目标 = e.目标;
    如果（目标.构成）{
      目标.组成 = false;
      目标.dispatchEvent（新事件（"输入"））；
    }
  }
  constassignKey = Symbol(“_assign”);
  const vModelText = {
    创建（el，{修饰符：{lazy，trim，number}}，vnode）{
      el[assignKey] = 获取模型分配器 (vnode);
      const castToNumber = number || vnode.props && vnode.props.type === “number”;
      addEventListener（el，lazy？“更改”：“输入”，（e）=> {
        如果（e.target.compose）返回；
        让 domValue = el.value;
        如果（修剪）{
          domValue = domValue.trim();
        }
        如果 (castToNumber) {
          domValue = looseToNumber（domValue）；
        }
        el[assignKey](domValue);
      });
      如果（修剪）{
        添加事件监听器（el，“改变”，（）=> {
          el.值 = el.值.trim();
        });
      }
      如果（！懒惰）{
        添加事件监听器（el， “compositionstart”，onCompositionStart）；
        添加事件监听器（el，“compositionend”，onCompositionEnd）；
        添加事件监听器（el，“改变”，onCompositionEnd）；
      }
    }，
    // 在安装时设置值，使其位于 type="range" 的最小值/最大值之后
    已安装（el，{值}）{
      el.value = value == null ? "" : 值;
    }，
    beforeUpdate(el， { 值， 旧值， 修饰符： { lazy， trim， number }}， vnode) {
      el[assignKey] = 获取模型分配器 (vnode);
      如果（el.compose）返回；
      const elValue = (number || el.type === "number") && !/^0\d/.test(el.value) ? looseToNumber(el.value) : el.value;
      const newValue = value == null ? "" : 值;
      如果 (elValue === newValue) {
        返回;
      }
      如果 (document.activeElement === el && el.type !== “range”) {
        如果（惰性&&值===旧值）{
          返回;
        }
        如果 (trim && el.value.trim() === newValue) {
          返回;
        }
      }
      el.值 = 新值;
    }
  };
  const vModelCheckbox = {
    // #4096 数组复选框需要深度遍历
    deep：真实，
    创建（el， _，vnode）{
      el[assignKey] = 获取模型分配器 (vnode);
      添加事件监听器（el，“改变”，（）=> {
        const modelValue = el._modelValue;
        const 元素值 = 获取值 (el);
        复制代码
        const 分配 = el[assignKey];
        如果（isArray（modelValue））{
          const 索引 = looseIndexOf（modelValue，elementValue）;
          const 找到 = 索引 !== -1;
          如果 (已检查 && !找到) {
            分配（modelValue.concat（elementValue））；
          } 否则，如果 (!检查 && 发现) {
            const 过滤 = [...modelValue];
            过滤.拼接（索引，1）；
            分配（过滤）；
          }
        } 否则，如果 (isSet (modelValue)) {
          const cloned = new Set（modelValue）;
          如果（已选中）{
            克隆.添加（元素值）；
          } 别的 {
            克隆.删除（元素值）；
          }
          分配（克隆）；
        } 别的 {
          分配（getCheckboxValue（el，已选中））；
        }
      });
    }，
    // 设置挂载时的初始检查以等待真值/假值
    安装：设置已选中，
    更新前（el，绑定，vnode）{
      el[assignKey] = 获取模型分配器 (vnode);
      设置Checked（el，binding，vnode）；
    }
  };
  函数 setChecked(el， { value， oldValue }， vnode) {
    el._modelValue = 值;
    让检查；
    如果 (isArray (值)) {
      检查 = looseIndexOf（值，vnode.props.值）> -1；
    } 否则，如果 (isSet (值)) {
      检查 = 值.具有（vnode.props.值）；
    } 别的 {
      如果（value === oldValue）返回；
      checked = looseEqual(值， getCheckboxValue(el， true));
    }
    如果（el.checked！==已检查）{
      el.checked = 已检查;
    }
  }
  const vModelRadio = {
    创建（el，{值}，vnode）{
      el.checked = looseEqual(值，vnode.props.值);
      el[assignKey] = 获取模型分配器 (vnode);
      添加事件监听器（el，“改变”，（）=> {
        el[assignKey](获取值(el));
      });
    }，
    beforeUpdate(el， { value， oldValue }， vnode) {
      el[assignKey] = 获取模型分配器 (vnode);
      如果（值！==旧值）{
        el.checked = looseEqual(值，vnode.props.值);
      }
    }
  };
  const vModelSelect = {
    // <select multiple> 值需要深度遍历
    deep：真实，
    创建（el，{值，修饰符：{数字}}，vnode）{
      const isSetModel = isSet（值）；
      添加事件监听器（el，“改变”，（）=> {
        const selectedVal = Array.prototype.filter.call(el.options, (o) => o.selected).map(
          （o）=> 数字？looseToNumber（getValue（o））：getValue（o）
        （英文）：
        el[assignKey](
          el.multiple？isSetModel？新设置（selectedVal）：selectedVal：selectedVal [0]
        （英文）：
        el._assigning = true;
        nextTick(() => {
          el._assigning = false;
        });
      });
      el[assignKey] = 获取模型分配器 (vnode);
    }，
    // 在 mounted 和 updated 中设置值，因为 <select> 依赖于其子项
    // <选项> 。
    已安装（el，{值}）{
      设置选定（el，值）；
    }，
    更新之前（el，_binding，vnode）{
      el[assignKey] = 获取模型分配器 (vnode);
    }，
    更新（el，{值}）{
      如果（！el._assigning）{
        设置选定（el，值）；
      }
    }
  };
  函数 setSelected（el，值）{
    const isMultiple = el.multiple;
    const isArrayValue = isArray(值);
    如果（isMultiple && ！isArrayValue && ！isSet（值））{
      警告（
        `<select multiple v-model> 期望其绑定为一个 Array 或 Set 值，但是得到的却是 ${Object.prototype.toString.call(value).slice(8, -1)}。`
      （英文）：
      返回;
    }
    对于（让 i = 0，l = el.options.length; i < l; i++）{
      const 选项 = el.options[i];
      const 选项值 = 获取选项值 (选项);
      如果 (是多个) {
        如果（isArrayValue）{
          const 选项类型 = 选项值的类型;
          如果 (optionType === “string” || optionType === “number”) {
            选项.selected = 值.some((v) => String(v) === String(optionValue));
          } 别的 {
            选项.selected = looseIndexOf(值，选项值) > -1;
          }
        } 别的 {
          选项.selected = 值.has(选项值);
        }
      } 否则，如果 (looseEqual(getValue(option), value)) {
        如果 (el.selectedIndex !== i) el.selectedIndex = i;
        返回;
      }
    }
    如果 (!isMultiple && el.selectedIndex !== -1) {
      el.selectedIndex = -1;
    }
  }
  函数获取值（el）{
    在 el ? el._value : el.value 中返回“_value”；
  }
  函数 getCheckboxValue(el，已选中) {
    const 键 = 已检查？“_trueValue”：“_falseValue”；
    返回 el 中的键？el[key] ：已检查；
  }
  const vModelDynamic = {
    创建（el，绑定，vnode）{
      callModelHook（el，binding，vnode，null，“created”）；
    }，
    已安装（el，绑定，vnode）{
      callModelHook(el，binding，vnode，null，“已安装”);
    }，
    beforeUpdate(el, 绑定, vnode, prevVNode) {
      callModelHook(el, 绑定, vnode, prevVNode, "beforeUpdate");
    }，
    更新（el，绑定，vnode，prevVNode）{
      callModelHook(el, 绑定, vnode, prevVNode, "更新");
    }
  };
  函数 resolveDynamicModel (标签名称，类型) {
    开关 (标签名称) {
      案例“选择”：
        返回 vModelSelect；
      案例“文本区域”：
        返回 vModelText；
      默认：
        开关（类型）{
          案例“复选框”：
            返回 vModelCheckbox；
          案例“收音机”：
            返回 vModelRadio；
          默认：
            返回 vModelText；
        }
    }
  }
  函数 callModelHook(el，binding，vnode，prevVNode，hook) {
    const modelToUse = 解析动态模型（
      el.标签名称，
      vnode.props && vnode.props.类型
    （英文）：
    const fn = modelToUse[hook];
    fn && fn(el, 绑定, vnode, prevVNode);
  }

  const systemModifiers = ["ctrl", "shift", "alt", "meta"];
  const modifierGuards = {
    停止：(e) => e.stopPropagation(),
    预防：（e）=> e.preventDefault（），
    自身：（e）=> e.target !== e.currentTarget，
    ctrl: (e) => !e.ctrlKey,
    移位：（e）=>！e.shiftKey，
    alt: (e) => !e.altKey,
    meta: (e) => !e.metaKey,
    左：（e）=>“按钮”在e&&e.button！==0，
    中间： (e) => “按钮” 在 e && e.button !== 1,
    右：（e）=> “按钮”在e && e.button !== 2，
    精确：（e，修饰符）=> systemModifiers.some（（m）=> e[`${m}Key`] && !modifiers.includes（m））
  };
  const withModifiers = (fn, modifiers) => {
    const 缓存 = fn._withMods || (fn._withMods = {});
    const cacheKey = modifiers.join(“.”);
    返回缓存[cacheKey] || (缓存[cacheKey] = (事件，...参数) => {
      对于（让 i = 0; i < 修饰符.length; i++）{
        const guard = modifierGuards[modifiers[i]];
        如果（guard && guard（event，modifiers））返回；
      }
      返回 fn（事件，...args）；
    });
  };
  const 键名 = {
    esc：“退出”，
    空间： ” ”，
    向上：“向上箭头”，
    左：“向左箭头”，
    右：“箭头右”，
    down: “向下箭头”，
    删除：“退格”
  };
  const withKeys = (fn, modifiers) => {
    const 缓存 = fn._withKeys || (fn._withKeys = {});
    const cacheKey = modifiers.join(“.”);
    返回缓存[cacheKey] || (缓存[cacheKey] = (事件) => {
      if (!(事件中的“key”)) {
        返回;
      }
      const eventKey = 连字符（event.key）;
      如果（修饰符.一些（
        (k) => k === eventKey || keyNames[k] === eventKey
      ））{
        返回 fn（事件）；
      }
    });
  };

  const rendererOptions = /* @__PURE__ */ 扩展（{ patchProp }， nodeOps）；
  让渲染器；
  让enabledHydration = false;
  函数确保渲染器（）{
    返回渲染器 || (渲染器=createRenderer(渲染器选项));
  }
  函数ensureHydrationRenderer（）{
    渲染器 = enabledHydration ?渲染器: createHydrationRenderer (渲染器选项);
    已启用Hydration = 真；
    返回渲染器；
  }
  const 渲染 = （...参数） => {
    确保Renderer().render(...args);
  };
  const 水合物 = （... 参数） => {
    确保HydrationRenderer（）。hydrate（...args）；
  };
  const createApp = (...args) => {
    const app = EnsureRenderer().createApp(...args);
    {
      注入NativeTagCheck（应用程序）；
      注入编译器选项检查（应用程序）；
    }
    const { mount } = 应用程序；
    app.mount = (containerOrSelector) => {
      const 容器 = normalizeContainer(containerOrSelector);
      如果（！容器）返回；
      const 组件 = app._component;
      如果（！isFunction（组件）&&！组件.render&&！组件.template）{
        组件.模板 = 容器.innerHTML;
      }
      如果 (容器.nodeType === 1) {
        容器.textContent = “”;
      }
      const 代理 = mount(container， false， resolveRootNamespace(container));
      如果（容器元素实例）{
        容器.removeAttribute（“v-cloak”）；
        容器.setAttribute（“data-v-app”，“”）；
      }
      返回代理；
    };
    返回应用程序；
  };
  const createSSRApp = (...args) => {
    const app = EnsureHydrationRenderer()。createApp（...args）；
    {
      注入NativeTagCheck（应用程序）；
      注入编译器选项检查（应用程序）；
    }
    const { mount } = 应用程序；
    app.mount = (containerOrSelector) => {
      const 容器 = normalizeContainer(containerOrSelector);
      如果（容器）{
        返回 mount(container, true, resolveRootNamespace(container));
      }
    };
    返回应用程序；
  };
  函数 resolveRootNamespace (容器) {
    如果（SVGElement容器实例）{
      返回“svg”；
    }
    如果 (typeof MathMLElement === “函数” && 容器实例 MathMLElement) {
      返回“mathml”；
    }
  }
  函数injectNativeTagCheck（应用程序）{
    Object.defineProperty（app.config，“isNativeTag”，{
      值：（标签）=> isHTMLTag（标签）|| isSVGTag(标签) || isMathMLTag(标签),
      可写：false
    });
  }
  函数注入编译器选项检查（app）{
    如果 (isRuntimeOnly()) {
      const isCustomElement = app.config.isCustomElement;
      Object.defineProperty（app.config，“isCustomElement”，{
        得到（） {
          返回 isCustomElement；
        }，
        放（） {
          警告（
            ``isCustomElement\` 配置选项已弃用。请改用 \`compilerOptions.isCustomElement\`。`
          （英文）：
        }
      });
      const 编译器选项 = app.config.编译器选项;
      const msg = ``compilerOptions\` 配置选项仅在使用包含运行时编译器的 Vue.js 构建（又称“完整构建”）时才有效。由于您使用的是仅运行时构建，因此必须在构建设置中将 \`compilerOptions\` 传递给 \`@vue/compiler-dom\`。
- 对于 vue-loader：通过 vue-loader 的 \`compilerOptions\` 加载器选项传递它。
- 对于 vue-cli：请参阅 https://cli.vuejs.org/guide/webpack.html#modifying-options-of-a-loader
- 对于 vite：通过 @vitejs/plugin-vue 选项传递。请参阅 https://github.com/vitejs/vite-plugin-vue/tree/main/packages/plugin-vue#example-for-passing-options-to-vuecompiler-sfc`;
      Object.defineProperty（app.config，“compilerOptions”，{
        得到（） {
          警告（信息）；
          返回编译器选项；
        }，
        放（） {
          警告（信息）；
        }
      });
    }
  }
  函数 normalizeContainer (容器) {
    如果（isString（容器））{
      const res = document.querySelector（容器）；
      如果（！res）{
        警告（
          `无法挂载应用程序：挂载目标选择器“${container}”返回 null。`
        （英文）：
      }
      返回 res；
    }
    如果 (window.ShadowRoot && 容器实例 window.ShadowRoot && 容器.mode === “closed”) {
      警告（
        `使用 \`{mode: "closed"}\` 安装 ShadowRoot 可能会导致不可预测的错误`
      （英文）：
    }
    返回容器；
  }
  const initDirectivesForSSR = NOOP;

  函数 initDev() {
    {
      {
        控制台.信息（
          `您正在运行 Vue 的开发版本。
在部署生产时，请确保使用生产版本 (*.prod.js)。`
        （英文）：
      }
      初始化自定义格式化程序（）；
    }
  }

  const FRAGMENT = Symbol(`片段` );
  const TELEPORT = Symbol(`传送门` );
  const SUSPENSE = Symbol(`Suspense` );
  const KEEP_ALIVE = Symbol(`KeepAlive` );
  const BASE_TRANSITION = 符号（
    `BaseTransition`
  （英文）：
  const OPEN_BLOCK = Symbol(`openBlock` );
  const CREATE_BLOCK = Symbol(`createBlock` );
  const CREATE_ELEMENT_BLOCK = 符号（
    `createElementBlock`
  （英文）：
  const CREATE_VNODE = Symbol(`创建VNode` );
  const CREATE_ELEMENT_VNODE = 符号（
    `createElementVNode`
  （英文）：
  const CREATE_COMMENT = 符号（
    `createCommentVNode`
  （英文）：
  const CREATE_TEXT = 符号（
    `创建文本节点`
  （英文）：
  const CREATE_STATIC = 符号（
    `createStaticVNode`
  （英文）：
  const RESOLVE_COMPONENT = 符号（
    `resolveComponent`
  （英文）：
  const RESOLVE_DYNAMIC_COMPONENT = 符号（
    `resolveDynamicComponent`
  （英文）：
  const RESOLVE_DIRECTIVE = 符号（
    `resolveDirective`
  （英文）：
  const RESOLVE_FILTER = 符号（
    `resolveFilter`
  （英文）：
  const WITH_DIRECTIVES = 符号（
    `withDirectives`
  （英文）：
  const RENDER_LIST = Symbol(`renderList` );
  const RENDER_SLOT = Symbol(`renderSlot` );
  const CREATE_SLOTS = Symbol(`createSlots` );
  const TO_DISPLAY_STRING = 符号（
    `toDisplayString`
  （英文）：
  const MERGE_PROPS = Symbol(`mergeProps` );
  const NORMALIZE_CLASS = 符号（
    `normalizeClass`
  （英文）：
  const NORMALIZE_STYLE = 符号（
    `normalizeStyle`
  （英文）：
  const NORMALIZE_PROPS = 符号（
    `normalizeProps`
  （英文）：
  const GUARD_REACTIVE_PROPS = 符号（
    `guardReactiveProps`
  （英文）：
  const TO_HANDLERS = Symbol(`toHandlers` );
  const CAMELIZE = 符号(`camelize` );
  const CAPITALIZE = Symbol(`大写` );
  const TO_HANDLER_KEY = 符号（
    `toHandlerKey`
  （英文）：
  const SET_BLOCK_TRACKING = 符号（
    `设置区块跟踪`
  （英文）：
  const PUSH_SCOPE_ID = 符号（`pushScopeId` ）；
  const POP_SCOPE_ID = 符号（`popScopeId` ）；
  const WITH_CTX = Symbol(`withCtx` );
  const UNREF = Symbol(`unref` );
  const IS_REF = 符号（`isRef` ）；
  const WITH_MEMO = Symbol(`withMemo` );
  const IS_MEMO_SAME = Symbol(`isMemoSame` );
  const helperNameMap = {
    [片段]：`片段`，
    [传送]：`传送`，
    [悬念]：“悬念”，
    [KEEP_ALIVE]：`保持活动`，
    [BASE_TRANSITION]：`BaseTransition`，
    [OPEN_BLOCK]：`打开区块`，
    [创建块]：`创建块`，
    [创建元素块]：`创建元素块`，
    [CREATE_VNODE]: `创建VNode`，
    [CREATE_ELEMENT_VNODE]: `创建元素VNode`，
    [创建评论]：`createCommentVNode`，
    [创建文本]：`createTextVNode`，
    [CREATE_STATIC]：`createStaticVNode`，
    [RESOLVE_COMPONENT]：`resolveComponent`，
    [解决动态组件]：`解决动态组件`，
    [解析指令]：`解析指令`，
    [RESOLVE_FILTER]：`解析过滤器`，
    [WITH_DIRECTIVES]：`带指令`，
    [渲染列表]：`渲染列表`，
    [RENDER_SLOT]：`renderSlot`，
    [创建槽]：`创建槽`，
    [TO_DISPLAY_STRING]：`到显示字符串`，
    [合并属性]：`mergeProps`，
    [NORMALIZE_CLASS]：`normalizeClass`，
    [NORMALIZE_STYLE]：`normalizeStyle`，
    [NORMALIZE_PROPS]：`normalizeProps`，
    [GUARD_REACTIVE_PROPS]: `guardReactiveProps`，
    [TO_HANDLERS]：`toHandlers`，
    [CAMELIZE]：`骆驼化`，
    [大写]：`大写`，
    [TO_HANDLER_KEY]: `toHandlerKey`，
    [设置区块跟踪]：`设置区块跟踪`，
    [PUSH_SCOPE_ID]: `推送范围ID`，
    [POP_SCOPE_ID]：`popScopeId`，
    [WITH_CTX]：`withCtx`，
    [取消引用]：`取消引用`，
    [IS_REF]：`isRef`，
    [带备注]：`带备注`，
    [IS_MEMO_SAME]: `isMemoSAME`
  };
  函数 registerRuntimeHelpers（帮助程序）{
    对象.getOwnPropertySymbols(助手).forEach((s) => {
      助手名称映射[s] = 助手[s];
    });
  }

  const locStub = {
    开始：{ 行：1， 列：1， 偏移量：0 }，
    结束：{ 行：1， 列：1， 偏移量：0 }，
    来源： ””
  };
  函数 createRoot（children，source =“”）{
    返回 {
      类型： 0，
      来源，
      孩子们，
      帮助程序：/*@__PURE__*/new Set()，
      成分： []，
      指令：[]，
      提升机：[]，
      进口：[]，
      缓存：[]，
      温度：0，
      codegenNode: void 0，
      loc：locStub
    };
  }
  函数 createVNodeCall（上下文，标签，道具，子项，patchFlag，dynamicProps，指令，isBlock = false，disableTracking = false，isComponent = false，loc = locStub）{
    如果（上下文）{
      如果 (是块) {
        上下文.帮助器（OPEN_BLOCK）；
        context.helper(获取VNodeBlockHelper(context.inSSR，isComponent));
      } 别的 {
        context.helper（getVNodeHelper（context.inSSR，isComponent））；
      }
      if（指令）{
        上下文.帮助器（WITH_DIRECTIVES）；
      }
    }
    返回 {
      类型： 13，
      标签，
      道具，
      孩子们，
      补丁标志，
      dynamicProps，
      指令，
      是块，
      禁用跟踪，
      是组件，
      洛
    };
  }
  函数 createArrayExpression（元素，loc = locStub）{
    返回 {
      类型：17，
      位置，
      元素
    };
  }
  函数 createObjectExpression（属性，loc = locStub）{
    返回 {
      类型： 15，
      位置，
      特性
    };
  }
  函数 createObjectProperty（键，值）{
    返回 {
      类型：16，
      位置： locStub，
      键：isString（键）？createSimpleExpression（键，true）：键，
      价值
    };
  }
  函数 createSimpleExpression（内容，isStatic = false，loc = locStub，constType = 0）{
    返回 {
      类型：4，
      位置，
      内容，
      是静态的，
      constType：是静态的吗？3：constType
    };
  }
  函数 createCompoundExpression(children，loc = locStub) {
    返回 {
      类型： 8，
      位置，
      孩子们
    };
  }
  函数 createCallExpression(被调用者, args = [], loc = locStub) {
    返回 {
      类型：14，
      位置，
      被叫方，
      参数：args
    };
  }
  函数 createFunctionExpression（params，返回 = void 0，newline = false，isSlot = false，loc = locStub）{
    返回 {
      类型： 18，
      参数，
      返回，
      换行符，
      是插槽，
      洛
    };
  }
  函数 createConditionalExpression（测试，结果，替代，换行符 = true）{
    返回 {
      类型： 19，
      测试，
      因此，
      备用，
      换行符，
      loc：locStub
    };
  }
  函数 createCacheExpression（索引，值，needPauseTracking = false，inVOnce = false）{
    返回 {
      类型： 20，
      指数，
      价值，
      需要暂停跟踪，
      曾经，
      需要ArraySpread：false，
      loc：locStub
    };
  }
  函数 createBlockStatement（主体）{
    返回 {
      类型： 21，
      身体，
      loc：locStub
    };
  }
  函数 getVNodeHelper(ssr，isComponent) {
    返回 ssr || isComponent ? CREATE_VNODE : CREATE_ELEMENT_VNODE;
  }
  函数 getVNodeBlockHelper(ssr，isComponent) {
    返回 ssr || isComponent ? CREATE_BLOCK : CREATE_ELEMENT_BLOCK;
  }
  函数 convertToBlock(node, { helper, removeHelper, inSSR }) {
    如果 (!node.isBlock) {
      节点.isBlock = true;
      删除Helper（getVNodeHelper（inSSR，node.isComponent））；
      助手（OPEN_BLOCK）；
      助手（getVNodeBlockHelper（inSSR，node.isComponent））；
    }
  }

  const defaultDelimitersOpen = new Uint8Array([123, 123]);
  const defaultDelimitersClose = new Uint8Array([125, 125]);
  函数 isTagStartChar(c) {
    返回 c >= 97 && c <= 122 || c >= 65 && c <= 90;
  }
  函数 isWhitespace（c）{
    返回 c === 32 || c === 10 || c === 9 || c === 12 || c === 13;
  }
  函数 isEndOfTagSection(c) {
    返回 c === 47 || c === 62 || isWhitespace(c);
  }
  函数 toCharCodes(str) {
    const ret = new Uint8Array(str.length);
    对于（让 i = 0; i < str.length; i++）{
      ret[i] = str.charCodeAt(i);
    }
    返回 ret；
  }
  const 序列 = {
    Cdata: new Uint8Array([67, 68, 65, 84, 65, 91]),
    //C数据[
    CdataEnd: new Uint8Array([93, 93 , 62]),
    // ]]>
    评论结束: new Uint8Array([45, 45, 62]),
    // `-->`
    ScriptEnd: new Uint8Array([60, 47, 115, 99, 114, 105, 112, 116]),
    // `<\/script`
    StyleEnd: new Uint8Array([60, 47, 115, 116, 121, 108, 101]),
    //`</style`
    标题结束: new Uint8Array([60, 47, 116, 105, 116, 108, 101]),
    // `</title`
    TextareaEnd: new Uint8Array([
      60，
      47岁，
      116，
      101，
      120，
      116，
      97，
      114，
      101，
      97
    ]）
    // `</textarea
  };
  类标记器 {
    构造函数（堆栈，cbs）{
      这个.stack = 堆栈;
      这个.cbs = cbs;
      /** 标记器当前所处的状态。 */
      这个.状态 = 1;
      /** 读取缓冲区。 */
      这个.缓冲区=“”;
      /** 当前正在读取的部分的开头。 */
      这个.sectionStart = 0;
      /** 我们当前正在查看的缓冲区内的索引。 */
      这个.索引 = 0;
      /** 最后一个实体的开始。 */
      这个.实体开始 = 0;
      /** 某些行为（例如解码实体时）是在我们处于另一种状态时完成的。这会跟踪其他状态类型。*/
      这个.baseState = 1;
      /** 用于脚本和样式标签内的特殊解析行为。 */
      这个.inRCDATA = false;
      /** 禁用 RCDATA 标签处理 */
      这个.inXML = false;
      /** 用于禁用 v-pre 中的插值解析 */
      这个.inVPre = false;
      /** 记录换行符位置，以便快速计算行/列 */
      这个.换行符=[];
      这个.模式 = 0;
      this.delimiterOpen = defaultDelimitersOpen;
      this.delimiterClose = 默认分隔符关闭；
      这个.分隔符索引 = -1;
      这个.currentSequence = void 0;
      这个.sequenceIndex = 0;
    }
    获取SFCRoot（）{
      返回 this.mode === 2 && this.stack.length === 0;
    }
    重置（） {
      这个.状态 = 1;
      这个.模式 = 0;
      这个.缓冲区=“”;
      这个.sectionStart = 0;
      这个.索引 = 0;
      这个.baseState = 1;
      这个.inRCDATA = false;
      这个.currentSequence = void 0;
      这个.换行符.长度 = 0;
      this.delimiterOpen = defaultDelimitersOpen;
      this.delimiterClose = 默认分隔符关闭；
    }
    /**
     * 使用记录生成带有行/列信息的 Position 对象
     * 换行位置。我们知道索引始终是已经
     * 处理索引，因此到该索引为止的所有换行符都应该是
     * 已记录。
     */
    获取Pos（索引）{
      让线= 1；
      让列 = 索引 + 1；
      对于（让 i = this.newlines.length - 1; i >= 0; i--）{
        const newlineIndex = this.newlines[i];
        如果 (索引 > 换行符索引) {
          行=i+2；
          列 = 索引 - 换行索引；
          休息;
        }
      }
      返回 {
        柱子，
        线，
        偏移量：索引
      };
    }
    偷看（）{
      返回 this.buffer.charCodeAt(this.index + 1);
    }
    状态文本（c）{
      如果 (c === 60) {
        如果（this.index > this.sectionStart）{
          这个.cbs.ontext（这个.sectionStart，这个.index）；
        }
        这个.状态 = 5;
        这个.sectionStart = 这个.index;
      } 否则，如果 (!this.inVPre && c === this.delimiterOpen[0]) {
        这个.状态 = 2;
        这个.分隔符索引 = 0;
        这个.stateInterpolationOpen（c）；
      }
    }
    stateInterpolationOpen（c）{
      如果 (c === this.delimiterOpen[this.delimiterIndex]) {
        如果 (this.delimiterIndex === this.delimiterOpen.length - 1) {
          const start = this.index + 1 - this.delimiterOpen.length;
          如果（开始 > this.sectionStart）{
            this.cbs.ontext（this.sectionStart，开始）；
          }
          这个.状态 = 3;
          这.sectionStart = 开始;
        } 别的 {
          这个.分隔符索引++；
        }
      } 否则，如果 (this.inRCDATA) {
        这个.状态 = 32;
        这个.stateInRCDATA（c）；
      } 别的 {
        这个.状态 = 1;
        这个.stateText（c）；
      }
    }
    状态插值（c）{
      如果 (c === this.delimiterClose[0]) {
        这个.状态 = 4;
        这个.分隔符索引 = 0;
        这个.stateInterpolationClose（c）；
      }
    }
    状态插值关闭（c）{
      如果 (c === this.delimiterClose[this.delimiterIndex]) {
        如果 (this.delimiterIndex === this.delimiterClose.length - 1) {
          这个.cbs.oninterpolation（这个.sectionStart，这个.index + 1）；
          如果（this.inRCDATA）{
            这个.状态 = 32;
          } 别的 {
            这个.状态 = 1;
          }
          这个.sectionStart = 这个.index + 1;
        } 别的 {
          这个.分隔符索引++；
        }
      } 别的 {
        这个.状态 = 3;
        这个.状态插值（c）；
      }
    }
    状态特殊开始序列（c）{
      const isEnd = this.sequenceIndex === this.currentSequence.length;
      const isMatch = isEnd? (
        // 如果我们处于序列的末尾，请确保标签名称已经结束
        isEndOfTagSection（c）
      ）：（
        // 否则，进行不区分大小写的比较
        （c | 32）===这个.currentSequence[这个.sequenceIndex]
      （英文）：
      如果 (!isMatch) {
        这个.inRCDATA = false;
      } 否则，如果（！isEnd）{
        这个.sequenceIndex ++；
        返回;
      }
      这个.sequenceIndex = 0;
      这个.状态 = 6;
      这个.stateInTagName（c）；
    }
    /** 查找结束标记。对于 <title> 和 <textarea>，还解码实体。*/
    stateInRCDATA（c）{
      如果 (this.sequenceIndex === this.currentSequence.length) {
        如果 (c === 62 || isWhitespace(c)) {
          const endOfText = this.index - this.currentSequence.length;
          如果 (this.sectionStart < endOfText) {
            const 实际索引 = 这个.索引；
            这个.index = 文本结束;
            这个.cbs.ontext（这个.sectionStart，endOfText）；
            这个.索引 = 实际索引；
          }
          这.sectionStart = endOfText + 2;
          这个.stateInClosingTagName（c）；
          这个.inRCDATA = false;
          返回;
        }
        这个.sequenceIndex = 0;
      }
      如果 ((c | 32) === this.currentSequence[this.sequenceIndex]) {
        这个.sequenceIndex += 1;
      } 否则，如果 (this.sequenceIndex === 0) {
        如果 (this.currentSequence === Sequences.TitleEnd || this.currentSequence === Sequences.TextareaEnd && !this.inSFCRoot) {
          如果（！这个.inVPre && c === 这个.delimiterOpen [0]）{
            这个.状态 = 2;
            这个.分隔符索引 = 0;
            这个.stateInterpolationOpen（c）；
          }
        } 否则，如果（this.fastForwardTo（60））{
          这个.sequenceIndex = 1;
        }
      } 别的 {
        this.sequenceIndex = Number(c === 60);
      }
    }
    状态CDATA序列（c）{
      如果 (c === Sequences.Cdata[this.sequenceIndex]) {
        如果 (++this.sequenceIndex === Sequences.Cdata.length) {
          这个.状态 = 28;
          这个.currentSequence = Sequences.CdataEnd;
          这个.sequenceIndex = 0;
          这个.sectionStart = 这个.index + 1;
        }
      } 别的 {
        这个.sequenceIndex = 0;
        这个.状态 = 23;
        这个.stateInDeclaration（c）；
      }
    }
    /**
     * 当我们等待一个特定的字符时，我们可以加快速度
     * 通过跳过缓冲区直到找到它。
     *
     * @returns 是否找到该字符。
     */
    fastForwardTo（c）{
      当 (++this.index < this.buffer.length) {
        const cc = this.buffer.charCodeAt(this.index);
        如果 (cc === 10) {
          这个.newlines.push（这个.index）；
        }
        如果 (cc === c) {
          返回 true；
        }
      }
      这个.索引 = 这个.缓冲区.长度 - 1;
      返回 false；
    }
    /**
     * 注释和 CDATA 以 `-->` 和 `]]>` 结尾。
     *
     * 他们的共同特点是：
     *-它们的结束序列具有它们开始的独特特征。
     * - 该字符重复，因此我们必须检查多次重复。
     * - 可以跳过序列的起始字符以外的所有字符。
     */
    stateInCommentLike(c) {
      如果 (c === this.currentSequence[this.sequenceIndex]) {
        如果 (++this.sequenceIndex === this.currentSequence.length) {
          如果（this.currentSequence === Sequences.CdataEnd）{
            这个.cbs.oncdata（这个.sectionStart，这个.index-2）；
          } 别的 {
            这个.cbs.oncomment（这个.sectionStart，这个.index-2）；
          }
          这个.sequenceIndex = 0;
          这个.sectionStart = 这个.index + 1;
          这个.状态 = 1;
        }
      } 否则，如果 (this.sequenceIndex === 0) {
        如果 (this.fastForwardTo(this.currentSequence[0])) {
          这个.sequenceIndex = 1;
        }
      } 否则，如果 (c !== this.currentSequence[this.sequenceIndex - 1]) {
        这个.sequenceIndex = 0;
      }
    }
    startSpecial（序列，偏移量）{
      this.enterRCDATA（序列，偏移量）；
      这个.状态 = 31;
    }
    EnterRCDATA（序列，偏移量）{
      这个.inRCDATA = true;
      这个.当前序列 = 序列;
      这个.sequenceIndex = 偏移量；
    }
    stateBeforeTagName（c）{
      如果 (c === 33) {
        这个.状态 = 22;
        这个.sectionStart = 这个.index + 1;
      } 否则，如果 (c === 63) {
        这个.状态 = 24;
        这个.sectionStart = 这个.index + 1;
      } 否则，如果 (isTagStartChar(c)) {
        这个.sectionStart = 这个.index;
        如果 (this.mode === 0) {
          这个.状态 = 6;
        } 否则，如果 (this.inSFCRoot) {
          这个.状态 = 34;
        } 否则，如果 (!this.inXML) {
          如果 (c === 116) {
            这个.状态 = 30;
          } 别的 {
            this.state = c === 115 ? 29 : 6;
          }
        } 别的 {
          这个.状态 = 6;
        }
      } 否则，如果 (c === 47) {
        这个.状态 = 8;
      } 别的 {
        这个.状态 = 1;
        这个.stateText（c）；
      }
    }
    stateInTagName(c) {
      如果（isEndOfTagSection（c））{
        这个.handleTagName（c）；
      }
    }
    stateInSFCRootTagName(c) {
      如果（isEndOfTagSection（c））{
        const 标签 = this.buffer.slice(this.sectionStart， this.index);
        如果（标签！==“模板”）{
          this.enterRCDATA(toCharCodes(`</` + tag), 0);
        }
        这个.handleTagName（c）；
      }
    }
    句柄标签名称(c) {
      this.cbs.onopentagname（this.sectionStart，this.index）；
      这个.sectionStart = -1;
      这个.状态 = 11;
      这个.stateBeforeAttrName（c）；
    }
    stateBeforeClosingTagName(c) {
      如果 (isWhitespace(c)) ; 否则如果 (c === 62) {
        {
          这个.cbs.onerr（14，这个.index）；
        }
        这个.状态 = 1;
        这个.sectionStart = 这个.index + 1;
      } 别的 {
        this.state = isTagStartChar(c) ? 9 : 27;
        这个.sectionStart = 这个.index;
      }
    }
    stateInClosingTagName（c）{
      如果 (c === 62 || isWhitespace(c)) {
        这个.cbs.onclosetag（这个.sectionStart，这个.index）；
        这个.sectionStart = -1;
        这个.状态 = 10;
        这个.stateAfterClosingTagName（c）；
      }
    }
    stateAfterClosingTagName（c）{
      如果 (c === 62) {
        这个.状态 = 1;
        这个.sectionStart = 这个.index + 1;
      }
    }
    stateBeforeAttrName（c）{
      如果 (c === 62) {
        这个.cbs.onopentagend（这个.index）；
        如果（this.inRCDATA）{
          这个.状态 = 32;
        } 别的 {
          这个.状态 = 1;
        }
        这个.sectionStart = 这个.index + 1;
      } 否则，如果 (c === 47) {
        这个.状态 = 7;
        如果（this.peek（）！== 62）{
          这个.cbs.onerr（22，这个.index）；
        }
      } 否则，如果 (c === 60 && this.peek() === 47) {
        这个.cbs.onopentagend（这个.index）；
        这个.状态 = 5;
        这个.sectionStart = 这个.index;
      } 否则，如果 (!isWhitespace(c)) {
        如果 (c === 61) {
          这个.cbs.onerr（
            19，
            这个.index
          （英文）：
        }
        这个.handleAttrStart（c）；
      }
    }
    handleAttrStart（c）{
      如果 (c === 118 && this.peek() === 45) {
        这个.状态 = 13;
        这个.sectionStart = 这个.index;
      } 否则，如果 (c === 46 || c === 58 || c === 64 || c === 35) {
        这个.cbs.ondirname（这个.index，这个.index + 1）；
        这个.状态 = 14;
        这个.sectionStart = 这个.index + 1;
      } 别的 {
        这个.状态 = 12;
        这个.sectionStart = 这个.index;
      }
    }
    stateInSelfClosingTag（c）{
      如果 (c === 62) {
        这个.cbs.onselfclosingtag（这个.index）；
        这个.状态 = 1;
        这个.sectionStart = 这个.index + 1;
        这个.inRCDATA = false;
      } 否则，如果 (!isWhitespace(c)) {
        这个.状态 = 11;
        这个.stateBeforeAttrName（c）；
      }
    }
    stateInAttrName（c）{
      如果 (c === 61 || isEndOfTagSection(c)) {
        这个.cbs.onattribname（这个.sectionStart，这个.index）；
        这个.handleAttrName结束（c）；
      } 否则，如果 (c === 34 || c === 39 || c === 60) {
        这个.cbs.onerr（
          17，
          这个.index
        （英文）：
      }
    }
    stateInDirName（c）{
      如果 (c === 61 || isEndOfTagSection(c)) {
        这个.cbs.ondirname（这个.sectionStart，这个.index）；
        这个.handleAttrName结束（c）；
      } 否则，如果 (c === 58) {
        这个.cbs.ondirname（这个.sectionStart，这个.index）；
        这个.状态 = 14;
        这个.sectionStart = 这个.index + 1;
      } 否则，如果 (c === 46) {
        这个.cbs.ondirname（这个.sectionStart，这个.index）；
        这个.状态 = 16;
        这个.sectionStart = 这个.index + 1;
      }
    }
    stateInDirArg（c）{
      如果 (c === 61 || isEndOfTagSection(c)) {
        这个.cbs.ondirarg（这个.sectionStart，这个.index）；
        这个.handleAttrName结束（c）；
      } 否则，如果 (c === 91) {
        这个.状态 = 15;
      } 否则，如果 (c === 46) {
        这个.cbs.ondirarg（这个.sectionStart，这个.index）；
        这个.状态 = 16;
        这个.sectionStart = 这个.index + 1;
      }
    }
    stateInDynamicDirArg（c）{
      如果 (c === 93) {
        这个.状态 = 14;
      } 否则，如果 (c === 61 || isEndOfTagSection(c)) {
        这个.cbs.ondirarg（这个.sectionStart，这个.index + 1）；
        这个.handleAttrName结束（c）；
        {
          这个.cbs.onerr（
            27，
            这个.index
          （英文）：
        }
      }
    }
    stateInDirModifier(c) {
      如果 (c === 61 || isEndOfTagSection(c)) {
        这个.cbs.ondirmodifier（这个.sectionStart，这个.index）；
        这个.handleAttrName结束（c）；
      } 否则，如果 (c === 46) {
        这个.cbs.ondirmodifier（这个.sectionStart，这个.index）；
        这个.sectionStart = 这个.index + 1;
      }
    }
    handleAttrNameEnd（c）{
      这个.sectionStart = 这个.index;
      这个.状态 = 17;
      this.cbs.onattribnameend(this.index);
      这个.stateAfterAttrName（c）；
    }
    stateAfterAttrName（c）{
      如果 (c === 61) {
        这个.状态 = 18;
      } 否则，如果 (c === 47 || c === 62) {
        this.cbs.onattribend(0, this.sectionStart);
        这个.sectionStart = -1;
        这个.状态 = 11;
        这个.stateBeforeAttrName（c）；
      } 否则，如果 (!isWhitespace(c)) {
        this.cbs.onattribend(0, this.sectionStart);
        这个.handleAttrStart（c）；
      }
    }
    stateBeforeAttrValue（c）{
      如果 (c === 34) {
        这个.状态 = 19;
        这个.sectionStart = 这个.index + 1;
      } 否则，如果 (c === 39) {
        这个.状态 = 20;
        这个.sectionStart = 这个.index + 1;
      } 否则，如果 (!isWhitespace(c)) {
        这个.sectionStart = 这个.index;
        这个.状态 = 21;
        这个.stateInAttrValueNoQuotes（c）；
      }
    }
    handleInAttrValue(c，引用) {
      如果 (c === quote || this.fastForwardTo(quote)) {
        这个.cbs.onattribdata（这个.sectionStart，这个.index）；
        这个.sectionStart = -1;
        这.cbs.onattribend（
          引用 === 34 ? 3 : 2,
          此索引 + 1
        （英文）：
        这个.状态 = 11;
      }
    }
    stateInAttrValueDoubleQuotes（c）{
      这个.handleInAttrValue（c，34）；
    }
    stateInAttrValueSingleQuotes(c) {
      这个.handleInAttrValue（c，39）；
    }
    stateInAttrValueNoQuotes（c）{
      如果 (isWhitespace(c) || c === 62) {
        这个.cbs.onattribdata（这个.sectionStart，这个.index）；
        这个.sectionStart = -1;
        这个.cbs.onattribud（1，这个.index）；
        这个.状态 = 11;
        这个.stateBeforeAttrName（c）；
      } 否则，如果 (c === 34 || c === 39 || c === 60 || c === 61 || c === 96) {
        这个.cbs.onerr（
          18，
          这个.index
        （英文）：
      } 别的 ;
    }
    声明前状态（c）{
      如果 (c === 91) {
        这个.状态 = 26;
        这个.sequenceIndex = 0;
      } 别的 {
        this.state = c === 45 ? 25 : 23;
      }
    }
    stateInDeclaration（c）{
      如果 (c === 62 || this.fastForwardTo(62)) {
        这个.状态 = 1;
        这个.sectionStart = 这个.index + 1;
      }
    }
    处理指令状态(c) {
      如果 (c === 62 || this.fastForwardTo(62)) {
        这个.cbs.onprocessinginstruction（这个.sectionStart，这个.index）；
        这个.状态 = 1;
        这个.sectionStart = 这个.index + 1;
      }
    }
    stateBeforeComment(c) {
      如果 (c === 45) {
        这个.状态 = 28;
        这个.currentSequence = Sequences.CommentEnd;
        这个.sequenceIndex = 2;
        这个.sectionStart = 这个.index + 1;
      } 别的 {
        这个.状态 = 23;
      }
    }
    stateInSpecialComment(c) {
      如果 (c === 62 || this.fastForwardTo(62)) {
        这个.cbs.oncomment（这个.sectionStart，这个.index）;
        这个.状态 = 1;
        这个.sectionStart = 这个.index + 1;
      }
    }
    stateBeforeSpecialS(c) {
      如果 (c === Sequences.ScriptEnd[3]) {
        这个.startSpecial（Sequences.ScriptEnd，4）；
      } 否则，如果 (c === Sequences.StyleEnd[3]) {
        这个.startSpecial（Sequences.StyleEnd，4）；
      } 别的 {
        这个.状态 = 6;
        这个.stateInTagName（c）；
      }
    }
    stateBeforeSpecialT(c) {
      如果 (c === Sequences.TitleEnd[3]) {
        这个.startSpecial（Sequences.TitleEnd，4）；
      } 否则，如果 (c === Sequences.TextareaEnd[3]) {
        这个.startSpecial（Sequences.TextareaEnd，4）；
      } 别的 {
        这个.状态 = 6;
        这个.stateInTagName（c）；
      }
    }
    开始实体() {
    }
    stateInEntity() {
    }
    /**
     * 遍历缓冲区，调用与当前状态相对应的函数。
     *
     * 更有可能受到打击的状态被置于更高的位置，以提高性能。
     */
    解析（输入）{
      这个.缓冲区=输入；
      当 (this.index < this.buffer.length) {
        const c = this.buffer.charCodeAt(this.index);
        如果 (c === 10) {
          这个.newlines.push（这个.index）；
        }
        切换（此.状态）{
          情况 1：{
            这个.stateText（c）；
            休息;
          }
          情况 2：{
            这个.stateInterpolationOpen（c）；
            休息;
          }
          情况 3： {
            这个.状态插值（c）；
            休息;
          }
          情况 4： {
            这个.stateInterpolationClose（c）；
            休息;
          }
          案例 31：{
            这个.stateSpecialStartSequence（c）；
            休息;
          }
          案例 32：{
            这个.stateInRCDATA（c）；
            休息;
          }
          案例 26：{
            这个.stateCDATASequence（c）；
            休息;
          }
          案例 19：{
            这个.stateInAttrValueDoubleQuotes（c）；
            休息;
          }
          案例 12：{
            这个.stateInAttrName（c）；
            休息;
          }
          案例 13：{
            这个.stateInDirName（c）；
            休息;
          }
          案例 14：{
            这个.stateInDirArg（c）；
            休息;
          }
          案例 15： {
            这个.stateInDynamicDirArg（c）；
            休息;
          }
          案例 16：{
            这个.stateInDirModifier（c）；
            休息;
          }
          案例 28：{
            这个.stateInCommentLike（c）；
            休息;
          }
          案例 27：{
            这个.stateInSpecialComment（c）；
            休息;
          }
          案例 11：{
            这个.stateBeforeAttrName（c）；
            休息;
          }
          情况 6： {
            这个.stateInTagName（c）；
            休息;
          }
          案例 34：{
            这个.stateInSFCRootTagName（c）；
            休息;
          }
          案例 9：{
            这个.stateInClosingTagName（c）；
            休息;
          }
          案例 5： {
            这个.stateBeforeTagName（c）；
            休息;
          }
          案例 17：{
            这个.stateAfterAttrName（c）；
            休息;
          }
          案例 20：{
            这个.stateInAttrValueSingleQuotes（c）；
            休息;
          }
          案例 18：{
            这个.stateBeforeAttrValue（c）；
            休息;
          }
          案例 8：{
            这个.stateBeforeClosingTagName（c）；
            休息;
          }
          案例 10：{
            这个.stateAfterClosingTagName（c）；
            休息;
          }
          案例 29：{
            这个.stateBeforeSpecialS（c）；
            休息;
          }
          案例 30：{
            这个.stateBeforeSpecialT（c）；
            休息;
          }
          案例 21：{
            这个.stateInAttrValueNoQuotes（c）；
            休息;
          }
          案例 7：{
            这个.stateInSelfClosingTag（c）；
            休息;
          }
          案例 23：{
            这个.stateInDeclaration（c）；
            休息;
          }
          案例 22：{
            这个.stateBeforeDeclaration（c）；
            休息;
          }
          案例 25：{
            这个.stateBeforeComment（c）；
            休息;
          }
          案例 24：{
            这个.stateInProcessingInstruction（c）；
            休息;
          }
          案例 33：{
            这个.stateInEntity()；
            休息;
          }
        }
        这个.索引++；
      }
      这个.清理（）；
      这个.完成（）；
    }
    /**
     * 从缓冲区中删除已经被使用的数据。
     */
    清理（​​） {
      如果 (this.sectionStart !== this.index) {
        如果 (this.state === 1 || this.state === 32 && this.sequenceIndex === 0) {
          这个.cbs.ontext（这个.sectionStart，这个.index）；
          这个.sectionStart = 这个.index;
        } 否则，如果 (this.state === 19 || this.state === 20 || this.state === 21) {
          这个.cbs.onattribdata（这个.sectionStart，这个.index）；
          这个.sectionStart = 这个.index;
        }
      }
    }
    结束（） {
      这个.处理尾随数据（）；
      这个.cbs.onend（）；
    }
    /** 处理任何尾随数据。 */
    处理尾随数据（）{
      const endIndex = this.buffer.length;
      如果 (this.sectionStart >= endIndex) {
        返回;
      }
      如果 (this.state === 28) {
        如果（this.currentSequence === Sequences.CdataEnd）{
          这个.cbs.oncdata（这个.sectionStart，endIndex）；
        } 别的 {
          这个.cbs.oncomment（这个.sectionStart，endIndex）;
        }
      } 否则，如果（这个.state === 6 || 这个.state === 11 || 这个.state === 18 || 这个.state === 17 || 这个.state === 12 || 这个.state === 13 || 这个.state === 14 || 这个.state === 15 || 这个.state === 16 || 这个.state === 20 || 这个.state === 19 || 这个.state === 21 || 这个.state === 9）；否则{
        这个.cbs.ontext（这个.sectionStart，endIndex）；
      }
    }
    发射代码点（cp，消耗）{
    }
  }

  函数 defaultOnError（错误）{
    抛出错误；
  }
  函数 defaultOnWarn（msg）{
    console.warn(`[Vue warn] ${msg.message}`);
  }
  函数 createCompilerError（代码，位置，消息，附加消息）{
    const msg = (消息 || 错误消息)[code] + (附加消息 || ``) ;
    const 错误 = 新的 SyntaxError(String(msg));
    错误.代码 = 代码;
    错误.loc = loc;
    返回错误；
  }
  const 错误消息 = {
    // 解析错误
    [0]: "非法评论。",
    [1]：“CDATA 部分仅允许在 XML 上下文中出现。”,
    [2]: “重复属性。”,
    [3]：“结束标签不能具有属性。”，
    [4]: “标签中的‘/’非法。”,
    [5]: “标签中出现意外的 EOF。”,
    [6]: “CDATA 部分出现意外的 EOF。”,
    [7]: “注释中出现意外的 EOF。”,
    [8]: “脚本中出现意外的 EOF。”,
    [9]: “标签中出现意外的 EOF。”,
    [10]：“错误地关闭了评论。”，
    [11]：“错误地打开了评论。”,
    [12]: “非法标签名称。使用‘<’打印‘<’。”,
    [13]：“预期属性值为。”,
    [14]: “预期为结束标签名称。”,
    [15]：“需要有空格。”，
    [16]：“注释中出现意外的‘<!--’。”,
    [17]: `属性名称不能包含 U+0022 (")、U+0027 (') 和 U+003C (<)。`，
    [18]：“不带引号的属性值不能包含 U+0022 (\")、U+0027 (')、U+003C (<)、U+003D (=) 和 U+0060 (`。””，
    [19]: “属性名称不能以‘=’开头。”,
    [21]：“‘<?’ 仅在 XML 上下文中允许。”
    [20]: `意外的空字符。`,
    [22]: “标签中的‘/’非法。”,
    // Vue 特定的解析错误
    [23]: “无效的结束标签。”,
    [24]：“元素缺少结束标记。”,
    [25]：“未找到插值结束符号。”,
    [27]: “未找到动态指令参数的结束括号。请注意，动态指令参数不能包含空格。”，
    [26]：“预期为法律指令名称。”，
    // 转换错误
    [28]: `v-if/v-else-if 缺少表达式。`，
    [29]: `v-if/else 分支必须使用唯一键。`，
    [30]: `v-else/v-else-if 没有相邻的 v-if 或 v-else-if。`，
    [31]: `v-for 缺少表达式。`，
    [32]: `v-for 有无效表达式。`,
    [33]: `<template v-for> 键应该放在 <template> 标签上。`，
    [34]: `v-bind 缺少表达式。`，
    [52]: `同名简写形式的 v-bind 仅允许静态参数。`，
    [35]: `v-on 缺少表达式。`，
    [36]: `<slot> 插座上出现意外的自定义指令。`,
    [37]: `在组件和嵌套的 <template> 上混合使用 v-slot。当有多个命名插槽时，所有插槽都应使用 <template> 语法以避免范围歧义。`，
    [38]: `发现重复的插槽名称。',
    [39]: `当组件已经有明确命名的默认插槽时，发现无关的子项。这些子项将被忽略。`，
    [40]: `v-slot 只能在组件或 <template> 标签上使用。`，
    [41]: `v-model 缺少表达式。`，
    [42]: `v-model 值必须是有效的 JavaScript 成员表达式。`，
    [43]: `v-model 不能用于 v-for 或 v-slot 范围变量，因为它们不可写。`，
    [44]: `v-model 不能用在 prop 上，因为本地 prop 绑定不可写。
使用 v-bind 绑定与发出 update:x 事件的 v-on 监听器相结合。`,
    [45]: `解析 JavaScript 表达式时出错: `,
    [46]: `<KeepAlive> 只需要一个子组件。`，
    [51]: `模板中的 @vnode-* 钩子不再受支持。请改用 vue: 前缀。例如，@vnode-mounted 应更改为 @vue:mounted。@vnode-* 钩子支持已在 3.4 版中被删除。`，
    // 一般错误
    [47]: `此版本的编译器不支持“prefixIdentifiers”选项。`，
    [48]: `此编译器版本不支持 ES 模块模式。`，
    [49]: ``仅当启用“prefixIdentifiers”选项时才支持“cacheHandlers”选项。`，
    [50]: `“scopeId”选项仅在模块模式下受支持。`，
    // 只是为了满足类型
    [53]：“
  };

  const isStaticExp = (p) => p.type === 4 && p.isStatic;
  函数 isCoreComponent（标签）{
    开关（标签）{
      案例“传送”：
      案例“传送”：
        返回 TELEPORT；
      案例“悬念”：
      案例“悬念”：
        返回 SUSPENSE；
      案例“KeepAlive”：
      案例“保持活力”：
        返回 KEEP_ALIVE；
      案例“BaseTransition”：
      案例“基础转换”：
        返回BASE_TRANSITION；
    }
  }
  const nonIdentifierRE = /^\d|[^\$\w\xA0-\uFFFF]/;
  const isSimpleIdentifier = (name) => !nonIdentifierRE.测试(name);
  const validFirstIdentCharRE = /[A-Za-z_$\xA0-\uFFFF]/;
  const validIdentCharRE = /[\.\?\w$\xA0-\uFFFF]/;
  const whitespaceRE = /\s+[.[]\s*|\s*[.[]\s+/g;
  const getExpSource = (exp) => exp.type === 4 ? exp.content : exp.loc.source;
  const isMemberExpressionBrowser = (exp) => {
    const path = getExpSource(exp).trim().replace(whitespaceRE，(s) => s.trim());
    让状态 = 0 /* inMemberExp */;
    让 stateStack = [];
    让 currentOpenBracketCount = 0;
    让 currentOpenParensCount = 0;
    让 currentStringType = null;
    对于（让 i = 0; i < 路径.长度; i++）{
      const char = path.charAt(i);
      切换（状态）{
        案例 0/* inMemberExp */：
          如果 (char ===“[”) {
            stateStack.推送（状态）；
            状态 = 1/* 括号内 */;
            当前打开括号数++；
          }否则，如果（char ===“（”）{
            stateStack.推送（状态）；
            状态 = 2 /* 在括号内 */;
            当前打开的参数数量++；
          } 否则，如果 (!(i === 0 ? validFirstIdentCharRE : validIdentCharRE).test(char)) {
            返回 false；
          }
          休息;
        案例 1 /* 括号内 */：
          如果（char ===`'`||char ===`“`||char ===“`”）{
            stateStack.推送（状态）；
            状态 = 3/* 字符串 */;
            当前字符串类型 = char;
          } 否则，如果 (char === `[`) {
            当前打开括号数++；
          } 否则，如果 (char === `]`) {
            如果 (!--currentOpenBracketCount) {
              状态 = stateStack.pop();
            }
          }
          休息;
        案例 2 /* 括号内 */：
          如果（char ===`'`||char ===`“`||char ===“`”）{
            stateStack.推送（状态）；
            状态 = 3/* 字符串 */;
            当前字符串类型 = char;
          }否则，如果（char ===`（`）{
            当前打开的参数数量++；
          } 否则，如果 (char === `)`) {
            如果 (i === 路径.长度 - 1) {
              返回 false；
            }
            如果 (!--currentOpenParensCount) {
              状态 = stateStack.pop();
            }
          }
          休息;
        情况 3 /* 字符串 */:
          如果 (char === currentStringType) {
            状态 = stateStack.pop();
            当前字符串类型 = 空;
          }
          休息;
      }
    }
    返回 !currentOpenBracketCount && !currentOpenParensCount;
  };
  复制代码
  const fnExpRE = /^\s*(async\s*)?(\([^)]*?\)|[\w$_]+)\s*(:[^=]+)?=>|^\s*(async\s+)?function(?:\s+[\w$]+)?\s*\(/;
  const isFnExpressionBrowser = (exp) => fnExpRE.test(getExpSource(exp));
  复制代码
  函数断言（条件，消息）{
    如果（！条件）{
      抛出新的错误（msg ||`意外的编译器条件`）；
    }
  }
  函数 findDir(节点，名称，allowEmpty = false) {
    对于（让 i = 0; i < node.props.length; i++）{
      const p = 节点.props[i];
      如果 (p.type === 7 && (allowEmpty || p.exp) && (isString(name) ? p.name === name : name.test(p.name))) {
        返回 p；
      }
    }
  }
  函数 findProp(节点，名称，dynamicOnly = false，allowEmpty = false) {
    对于（让 i = 0; i < node.props.length; i++）{
      const p = 节点.props[i];
      如果 (p.类型 === 6) {
        如果（dynamicOnly）继续；
        如果 (p.name === name && (p.value || allowEmpty)) {
          返回 p；
        }
      } 否则，如果 (p.name === “bind” && (p.exp || allowEmpty) && isStaticArgOf(p.arg, name)) {
        返回 p；
      }
    }
  }
  函数 isStaticArgOf(arg，名称) {
    返回！（arg && isStaticExp（arg）&& arg.content === name）；
  }
  函数 hasDynamicKeyVBind（节点）{
    返回节点.props.some（
      （p）=> p.type === 7 && p.name === “bind” && （！p.arg || // v-bind =“obj”
      p.arg.type !== 4 || // v-bind:[_ctx.foo]
      !p.arg.是静态的)
      // v-bind:[foo]
    （英文）：
  }
  函数 isText$1(节点) {
    返回节点.类型===5 ||节点.类型===2;
  }
  函数 isVSlot(p) {
    返回 p.type === 7 && p.name === “slot”;
  }
  函数 isTemplateNode (节点) {
    返回节点.类型===1&&节点.tagType===3;
  }
  函数 isSlotOutlet (节点) {
    返回节点.类型===1&&节点.tagType===2；
  }
  const propsHelperSet = /* @__PURE__ */ new Set([NORMALIZE_PROPS, GUARD_REACTIVE_PROPS]);
  函数 getUnnormalizedProps(props，callPath = []) {
    如果 (props && !isString(props) && props.type === 14) {
      const callee = props.callee;
      if (!isString(callee) && propsHelperSet.has(callee)) {
        返回 getUnnormalizedProps(
          props.参数[0]，
          callPath.concat（props）
        （英文）：
      }
    }
    返回 [props，callPath]；
  }
  函数injectProp（节点，prop，上下文）{
    让 propsWithInjection；
    让 props = node.type === 13 ?node.props : node.arguments[2];
    让 callPath = [];
    让父母呼叫；
    如果 (props && !isString(props) && props.type === 14) {
      复制代码
      道具 = ret[0];
      调用路径 = ret[1];
      parentCall = callPath[callPath.length - 1];
    }
    如果 (props == null || isString(props)) {
      propsWithInjection = createObjectExpression([prop]);
    } 否则，如果 (props.type === 14) {
      const first = props.arguments[0];
      如果 (!isString(first) && first.type === 15) {
        如果 (!hasProp(prop，first)) {
          首先.属性.unshift（prop）；
        }
      } 别的 {
        如果 (props.callee === TO_HANDLERS) {
          propsWithInjection = createCallExpression（context.helper（MERGE_PROPS），[
            创建对象表达式（[prop]），
            道具
          ]);
        } 别的 {
          复制代码
        }
      }
      ！propsWithInjection && (propsWithInjection = props);
    } 否则，如果 (props.type === 15) {
      如果 (!hasProp(prop，props)) {
        属性.properties.unshift(prop);
      }
      道具与注入 = 道具;
    } 别的 {
      propsWithInjection = createCallExpression（context.helper（MERGE_PROPS），[
        创建对象表达式（[prop]），
        道具
      ]);
      如果 (parentCall && parentCall.callee === GUARD_REACTIVE_PROPS) {
        parentCall = callPath[callPath.length - 2];
      }
    }
    如果 (节点类型 === 13) {
      如果 (父调用) {
        parentCall.arguments[0] = propsWithInjection;
      } 别的 {
        节点.props = propsWithInjection;
      }
    } 别的 {
      如果 (父调用) {
        parentCall.arguments[0] = propsWithInjection;
      } 别的 {
        节点.参数[2] = propsWithInjection;
      }
    }
  }
  函数 hasProp(prop， props) {
    让结果 = false;
    如果 (prop.key.type === 4) {
      const propKeyName = prop.key.内容;
      结果 = props.properties.some(
        （p）=> p.key.type === 4 && p.key.content === propKeyName
      （英文）：
    }
    返回结果；
  }
  函数 toValidAssetId (名称，类型) {
    返回 `_${type}_${name.replace(/[^\w]/g, (searchValue, replaceValue) => {
    返回 searchValue ===“-”？“_”：name.charCodeAt（replaceValue）.toString（）;
  }）}`；
  }
  函数 getMemoedVNodeCall(节点) {
    if (node.type === 14 && node.callee === WITH_MEMO) {
      返回节点.参数[1].返回；
    } 别的 {
      返回节点；
    }
  }
  const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+(\S[\s\S]*)/;

  const 默认解析器选项 = {
    解析模式：“base”，
    ns：0，
    分隔符：[`{{`, `}}`]，
    获取命名空间： () => 0，
    isVoidTag: 否，
    isPreTag: 否，
    isIgnoreNewlineTag: NO，
    isCustomElement: 否，
    onError: defaultOnError，
    onWarn：默认OnWarn，
    评论：正确，
    前缀标识符：false
  };
  让 currentOptions = defaultParserOptions;
  让 currentRoot = null;
  让当前输入 = “”;
  让 currentOpenTag = null;
  让 currentProp = null;
  让 currentAttrValue = "";
  让 currentAttrStartIndex = -1；
  让 currentAttrEndIndex = -1；
  让 inPre = 0;
  让 inVPre = false;
  让 currentVPreBoundary = null;
  const 堆栈 = [];
  const tokenizer = new Tokenizer(stack，{
    onerr：发出错误，
    ontext（开始，结束）{
      onText（getSlice（开始，结束），开始，结束）；
    }，
    ontextentity（char，开始，结束）{
      onText（字符，开始，结束）；
    }，
    oninterpolation（开始，结束）{
      如果（inVPre）{
        返回 onText(getSlice(开始，结束)，开始，结束);
      }
      让 innerStart = start + tokenizer.delimiterOpen.length;
      让innerEnd =结束 - tokenizer.delimiterClose.length;
      while (isWhitespace(currentInput.charCodeAt(innerStart))) {
        内部开始++；
      }
      while (isWhitespace(currentInput.charCodeAt(innerEnd - 1))) {
        内端--；
      }
      让 exp = getSlice(innerStart, innerEnd);
      如果 (exp.includes("&")) {
        {
          exp = 当前选项.解码实体（exp，false）；
        }
      }
      添加节点（{
        类型： 5，
        内容：createExp(exp, false, getLoc(innerStart, innerEnd)),
        loc：getLoc（开始，结束）
      });
    }，
    onopentagname（开始，结束）{
      const 名称 = getSlice（开始，结束）;
      当前打开标签 = {
        类型：1，
        标签： 名称，
        ns：currentOptions.getNamespace（名称，堆栈[0]，currentOptions.ns），
        标签类型: 0,
        // 将在标签关闭时进行改进
        道具：[]，
        孩子们： []，
        loc: getLoc(开始 - 1，结束)，
        codegenNode: void 0
      };
    }，
    onopentagend（结束）{
      结束打开标签（结束）；
    }，
    onclosetag（开始，结束）{
      const 名称 = getSlice（开始，结束）;
      如果 (!currentOptions.isVoidTag(名称)) {
        让 found = false;
        对于（让 i = 0; i < stack.length; i++）{
          const e = 堆栈[i];
          如果 (e.tag.toLowerCase() === name.toLowerCase()) {
            找到=真；
            如果 (i > 0) {
              发出错误（24，stack[0].loc.start.offset）；
            }
            对于（设 j = 0；j <= i；j++）{
              const el = stack.shift();
              onCloseTag（el，结束，j < i）；
            }
            休息;
          }
        }
        如果（！找到）{
          发出错误（23，backTrack（start，60））；
        }
      }
    }，
    onselfclosingtag（结束）{
      const 名称 = currentOpenTag.tag;
      当前打开标签.是否自行关闭 = true;
      结束打开标签（结束）；
      if (stack[0] && stack[0].tag === name) {
        onCloseTag（stack.shift（，结束）；
      }
    }，
    onattribname（开始，结束）{
      currentProp = {
        类型： 6，
        名称：getSlice（开始，结束），
        nameLoc: getLoc(开始，结束)，
        值：void 0，
        loc: getLoc(开始)
      };
    }，
    ondirname (开始，结束) {
      const raw = getSlice（开始，结束）;
      const name = raw === "." || raw === ":" ? "bind" : raw === "@" ? "on" : raw === "#" ? "slot" : raw.slice(2);
      如果 (!inVPre && name === "") {
        发出错误（26，开始）；
      }
      如果 (inVPre || 名称 === “”) {
        currentProp = {
          类型： 6，
          名称： raw,
          nameLoc: getLoc(开始，结束)，
          值：void 0，
          loc: getLoc(开始)
        };
      } 别的 {
        currentProp = {
          类型： 7，
          姓名，
          rawName： raw，
          exp: void 0，
          参数：void 0，
          修饰符：raw ===“。”？[createSimpleExpression（“prop”）] : []，
          loc: getLoc(开始)
        };
        如果 (名称 === “pre”) {
          inVPre = tokenizer.inVPre = true;
          当前VPreBoundary = 当前OpenTag；
          const props = currentOpenTag.props;
          对于（让 i = 0; i < props.length; i++）{
            如果 (props[i].type === 7) {
              props[i] = dirToAttr(props[i]);
            }
          }
        }
      }
    }，
    ondirarg（开始，结束）{
      如果（开始===结束）返回；
      const arg = getSlice（开始，结束）；
      如果（inVPre）{
        currentProp.名称 += arg;
        设置LocEnd（currentProp.nameLoc，结束）；
      } 别的 {
        const isStatic = arg[0] !== `[`;
        currentProp.arg = createExp(
          是静态的吗？arg：arg.slice（1，-1），
          是静态的，
          getLoc(开始，结束)，
          是否静态？3 : 0
        （英文）：
      }
    }，
    ondirmodifier（开始，结束）{
      const mod = getSlice（开始，结束）；
      如果（inVPre）{
        currentProp.name += "." + 模组；
        设置LocEnd（currentProp.nameLoc，结束）；
      } 否则，如果 (currentProp.name === “slot”) {
        const arg = currentProp.arg;
        如果（参数）{
          arg.内容+ =“。”+ mod;
          设置LocEnd（arg.loc，结束）；
        }
      } 别的 {
        const exp = createSimpleExpression(mod， true，getLoc(start，end));
        currentProp.modifiers.push(exp);
      }
    }，
    onattribdata（开始，结束）{
      currentAttrValue += getSlice（开始，结束）；
      如果 (currentAttrStartIndex < 0) currentAttrStartIndex = 开始;
      当前AttrEndIndex = 结束；
    }，
    onattribuntity（字符，开始，结束）{
      当前属性值 += char;
      如果 (currentAttrStartIndex < 0) currentAttrStartIndex = 开始;
      当前AttrEndIndex = 结束；
    }，
    onattribnameend(结束) {
      const 开始 = currentProp.loc.开始.偏移量;
      const 名称 = getSlice（开始，结束）;
      如果 (currentProp.type === 7) {
        currentProp.rawName = 名称；
      }
      如果（currentOpenTag.props.some（
        （p）=>（p.type === 7？p.rawName：p.name）===名称
      ））{
        发出错误（2，开始）；
      }
    }，
    onattribend（引用，结束）{
      如果 (currentOpenTag && currentProp) {
        设置LocEnd（currentProp.loc，结束）；
        如果（引用！== 0）{
          如果 (currentAttrValue.includes("&")) {
            currentAttrValue = currentOptions.decodeEntities（
              currentAttrValue，
              真的
            （英文）：
          }
          如果 (currentProp.type === 6) {
            如果 (currentProp.name === “class”) {
              currentAttrValue = 凝聚（currentAttrValue）。修剪（）;
            }
            如果（引用=== 1 && ！currentAttrValue）{
              发出错误（13，结束）；
            }
            currentProp.值 = {
              类型：2，
              内容：currentAttrValue，
              loc：quote === 1？getLoc（currentAttrStartIndex，currentAttrEndIndex）：getLoc（currentAttrStartIndex - 1，currentAttrEndIndex + 1）
            };
            如果 (tokenizer.inSFCRoot && currentOpenTag.tag === “模板” && currentProp.name === “lang” && currentAttrValue && currentAttrValue !== “html”) {
              tokenizer.enterRCDATA(toCharCodes(`</template`), 0);
            }
          } 别的 {
            让 expParseMode = 0 /* 正常 */;
            currentProp.exp = createExp(
              currentAttrValue，
              错误的，
              获取当前AttrStartIndex和当前AttrEndIndex位置
              0，
              解析模式
            （英文）：
            如果 (currentProp.name === “for”) {
              currentProp.forParseResult = parseForExpression(currentProp.exp);
            }
          }
        }
        如果 (currentProp.type !== 7 || currentProp.name !== "pre") {
          currentOpenTag.props.push(currentProp);
        }
      }
      当前属性值 = “”;
      当前属性起始索引 = 当前属性结束索引 = -1;
    }，
    oncomment（开始，结束）{
      如果（currentOptions.comments）{
        添加节点（{
          类型： 3，
          内容：getSlice（开始，结束），
          loc：getLoc（开始 - 4，结束 + 3）
        });
      }
    }，
    结束（）{
      const end = currentInput.length;
      如果（tokenizer.state！== 1）{
        切换（tokenizer.state）{
          案例5：
          案例8：
            发出错误（5，结束）；
            休息;
          案例 3：
          案例4：
            发出错误（
              25岁，
              tokenizer.sectionStart
            （英文）：
            休息;
          案例28：
            如果 (tokenizer.currentSequence === Sequences.CdataEnd) {
              发出错误（6，结束）；
            } 别的 {
              发出错误（7，结束）；
            }
            休息;
          案例六：
          案例7：
          案例9：
          案例11：
          案例12：
          案例13：
          案例14：
          案例15：
          案例16：
          案例17：
          案例18：
          案例19：
          //“
          案例20：
          //'
          案例21：
            发出错误（9，结束）；
            休息;
        }
      }
      对于（让索引 = 0；索引 < 堆栈.长度；索引++）{
        onCloseTag（堆栈[索引]，结束-1）；
        发出错误（24，堆栈[index].loc.start.offset）；
      }
    }，
    oncdata（开始，结束）{
      如果 (堆栈[0].ns !== 0) {
        onText（getSlice（开始，结束），开始，结束）；
      } 别的 {
        发出错误（1，开始 - 9）；
      }
    }，
    onprocessinginstruction（开始）{
      如果（（堆栈[0]？堆栈[0].ns：currentOptions.ns）=== 0）{
        发出错误（
          21岁，
          开始 - 1
        （英文）：
      }
    }
  });
  const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
  const stripParensRE = /^\(|\)$/g;
  函数 parseForExpression(输入) {
    const loc = 输入.loc;
    const exp = 输入.内容;
    复制代码
    如果（！inMatch）返回；
    const [, LHS, RHS] = 匹配；
    const createAliasExpression = (内容，偏移量，asParam = false) => {
      const 开始 = loc.开始.偏移量 + 偏移量；
      const 结束 = 开始 + 内容.长度;
      返回 createExp(
        内容，
        错误的，
        getLoc(开始，结束)，
        0，
        asParam ? 1 /* 参数 */ : 0 /* 正常 */
      （英文）：
    };
    const 结果 = {
      来源：createAliasExpression（RHS.trim（），exp.indexOf（RHS，LHS.length）），
      值：void 0，
      键：void 0，
      索引：void 0，
      最终确定：错误
    };
    让 valueContent = LHS.trim().replace(stripParensRE，“”）。trim()；
    const trimmedOffset = LHS.indexOf(valueContent);
    const iteratorMatch = valueContent.match(forIteratorRE);
    如果（迭代器匹配）{
      valueContent = valueContent.replace(forIteratorRE, "").trim();
      const keyContent = iteratorMatch[1].trim();
      让键偏移；
      如果 (关键内容) {
        keyOffset = exp.indexOf(keyContent，trimmedOffset + valueContent.length);
        结果.key = createAliasExpression(keyContent，keyOffset，true);
      }
      如果 (迭代器匹配 [2]) {
        const indexContent = iteratorMatch[2].trim();
        如果（索引内容）{
          结果.索引 = createAliasExpression(
            索引内容，
            exp.indexOf（
              索引内容，
              结果.key ? keyOffset + keyContent.length : trimmedOffset + valueContent.length
            ),
            真的
          （英文）：
        }
      }
    }
    如果（值内容）{
      结果.值 = createAliasExpression(valueContent，trimmedOffset，true);
    }
    返回结果；
  }
  函数 getSlice (开始，结束) {
    返回当前输入.slice（开始，结束）；
  }
  函数endOpenTag（结束）{
    如果（tokenizer.inSFCRoot）{
      currentOpenTag.innerLoc = getLoc(end + 1, end + 1);
    }
    添加节点（当前打开标签）；
    const { tag，ns } = currentOpenTag;
    如果 (ns === 0 && currentOptions.isPreTag(tag)) {
      在Pre++中；
    }
    如果 (currentOptions.isVoidTag(tag)) {
      onCloseTag（当前打开标签，结束）；
    } 别的 {
      堆栈.unshift（当前打开标签）；
      如果 (ns === 1 || ns === 2) {
        tokenizer.inXML = true;
      }
    }
    当前打开标签 = 空；
  }
  函数 onText（内容，开始，结束）{
    {
      const 标签 = 堆栈[0] && 堆栈[0].标签;
      如果（标签！==“脚本”&&标签！==“样式”&&内容.includes（“&”））{
        内容 = 当前选项.解码实体 (内容， false);
      }
    }
    const 父级 = 堆栈[0] || 当前根；
    const lastNode = 父节点.children[父节点.children.length - 1];
    if (lastNode && lastNode.type === 2) {
      最后节点.内容 += 内容;
      设置LocEnd（lastNode.loc，结束）；
    } 别的 {
      父母.孩子.推（{
        类型：2，
        内容，
        loc：getLoc（开始，结束）
      });
    }
  }
  函数 onCloseTag（el，end，isImplied = false）{
    如果（隐含）{
      setLocEnd(el.loc， backTrack(end， 60));
    } 别的 {
      setLocEnd(el.loc，lookAhead(end，62) + 1);
    }
    如果（tokenizer.inSFCRoot）{
      如果（el.children.length）{
        el.innerLoc.end = 扩展（{}，el.children[el.children.length - 1].loc.end）；
      } 别的 {
        el.innerLoc.end = 扩展({}, el.innerLoc.start);
      }
      el.innerLoc.source = getSlice(
        el.innerLoc.起始.偏移量，
        el.innerLoc.end.偏移量
      （英文）：
    }
    const { 标签， ns， 儿童 } = el;
    如果 (!inVPre) {
      如果 (标签 === “插槽”) {
        el.标签类型 = 2;
      } 否则，如果 (isFragmentTemplate(el)) {
        el.标签类型 = 3;
      } 否则，如果 (isComponent(el)) {
        el.标签类型 = 1;
      }
    }
    如果（！tokenizer.inRCDATA）{
      el.children = condenseWhitespace(children);
    }
    如果 (ns === 0 && currentOptions.isIgnoreNewlineTag(tag)) {
      const first = children[0];
      如果 (first && first.type === 2) {
        first.content = first.content.replace(/^\r?\n /, “” );
      }
    }
    如果 (ns === 0 && currentOptions.isPreTag(tag)) {
      在前--；
    }
    如果 (currentVPreBoundary === el) {
      inVPre = tokenizer.inVPre = false;
      当前VPreBoundary = 空；
    }
    如果（tokenizer.inXML &&（stack[0]？stack[0].ns：currentOptions.ns）=== 0）{
      tokenizer.inXML = false;
    }
  }
  函数 lookAhead (索引， c) {
    让 i = 索引；
    当 (currentInput.charCodeAt(i) !== c && i < currentInput.length - 1) i++;
    返回我；
  }
  函数 backTrack(index，c) {
    让 i = 索引；
    当 (currentInput.charCodeAt(i) !== c && i >= 0) i--;
    返回我；
  }
  const specialTemplateDir = /* @__PURE__ */ new Set(["if", "else", "else-if", "for", "slot"]);
  函数 isFragmentTemplate({ 标签， 道具 }) {
    如果（标签===“模板”）{
      对于（让 i = 0; i < props.length; i++）{
        如果 (props[i].type === 7 && specialTemplateDir.has(props[i].name)) {
          返回 true；
        }
      }
    }
    返回 false；
  }
  函数 isComponent({ 标签， props }) {
    如果 (currentOptions.isCustomElement(标签)) {
      返回 false；
    }
    如果 (tag === “组件” || isUpperCase(tag.charCodeAt(0)) || isCoreComponent(tag) || currentOptions.isBuiltInComponent && currentOptions.isBuiltInComponent(tag) || currentOptions.isNativeTag && !currentOptions.isNativeTag(tag)) {
      返回 true；
    }
    对于（让 i = 0; i < props.length; i++）{
      const p = props[i];
      如果 (p.类型 === 6) {
        如果 (p.name === “是” && p.value) {
          如果 (p.value.content.startsWith("vue:")) {
            返回 true；
          }
        }
      }
    }
    返回 false；
  }
  函数 isUpperCase(c) {
    返回 c > 64 && c < 91;
  }
  const windowsNewlineRE = /\r\n/g;
  函数 condenseWhitespace（节点，标签）{
    const shouldCondense = currentOptions.whitespace !== "preserve";
    让 removedWhitespace = false;
    对于（让 i = 0; i < 节点.长度; i++）{
      const 节点 = 节点[i];
      如果 (节点.类型 === 2) {
        如果 (!inPre) {
          如果（isAllWhitespace（node.content））{
            const prev = 节点[i - 1] && 节点[i - 1].类型;
            const next = 节点[i + 1] && 节点[i + 1].类型;
            如果 (!prev || !next || shouldCondense && (prev === 3 && (next === 3 || next === 1) || prev === 1 && (next === 3 || next === 1 && hasNewlineChar(node.content)))) {
              删除的空白 = true;
              节点[i] = 空;
            } 别的 {
              节点.内容 = “ “;
            }
          } 否则，如果（应该压缩）{
            节点.内容 = 浓缩(节点.内容);
          }
        } 别的 {
          节点.内容 = 节点.内容.替换（windowsNewlineRE，“\n”）；
        }
      }
    }
    返回 removedWhitespace ? nodes.filter(Boolean) : nodes;
  }
  函数 isAllWhitespace（str）{
    对于（让 i = 0; i < str.length; i++）{
      如果 (!isWhitespace(str.charCodeAt(i))) {
        返回 false；
      }
    }
    返回 true；
  }
  函数 hasNewlineChar(str) {
    对于（让 i = 0; i < str.length; i++）{
      const c = str.charCodeAt(i);
      如果 (c === 10 || c === 13) {
        返回 true；
      }
    }
    返回 false；
  }
  函数 condense(str) {
    让 ret = "";
    让 prevCharIsWhitespace = false;
    对于（让 i = 0; i < str.length; i++）{
      如果 (isWhitespace(str.charCodeAt(i))) {
        如果 (!prevCharIsWhitespace) {
          ret +=“ “;
          上一个字符是空白 = true;
        }
      } 别的 {
        ret += str[i];
        上一个CharIsWhitespace = false;
      }
    }
    返回 ret；
  }
  函数添加节点（节点）{
    （stack[0] || currentRoot).children.push（节点）；
  }
  函数 getLoc (开始，结束) {
    返回 {
      开始：tokenizer.getPos（开始），
      // @ts-expect-error 允许延迟附加
      结束：结束==null？结束：tokenizer.getPos（结束），
      // @ts-expect-error 允许延迟附加
      源：end == null ? end : getSlice (start, end)
    };
  }
  函数 cloneLoc（loc）{
    返回 getLoc(loc.start.offset, loc.end.offset);
  }
  函数 setLocEnd(loc，end) {
    loc.end = tokenizer.getPos(end);
    loc.source = getSlice(loc.start.offset，结束);
  }
  函数 dirToAttr(dir) {
    const 属性 = {
      类型： 6，
      名称： dir.rawName，
      nameLoc: 获取位置（
        目录.loc.起始.偏移量，
        dir.loc.起始.偏移量 + dir.rawName.长度
      ),
      值：void 0，
      loc： dir.loc
    };
    如果 (目录.exp) {
      const loc = dir.exp.loc;
      如果 (loc.end.offset < dir.loc.end.offset) {
        位置.起始.偏移量--;
        位置.起始.列--;
        位置.结束.偏移++;
        位置.结束.列++；
      }
      属性值 = {
        类型：2，
        内容： dir.exp.content，
        洛
      };
    }
    返回属性；
  }
  函数 createExp(content, isStatic = false, loc, constType = 0, parseMode = 0 /* 正常 */) {
    const exp = createSimpleExpression(内容， isStatic， loc， constType);
    返回 exp；
  }
  函数 emitError（代码、索引、消息）{
    currentOptions.onError（
      createCompilerError（代码，getLoc（索引，索引），void 0，消息）
    （英文）：
  }
  函数重置（）{
    标记器.重置()；
    当前打开标签 = 空；
    当前属性 = 空;
    当前属性值 = “”;
    当前属性起始索引 = -1;
    当前属性结束索引 = -1;
    堆栈.长度 = 0;
  }
  函数 baseParse (输入，选项) {
    重置（）;
    当前输入 = 输入；
    当前选项 = 扩展（{}，默认解析器选项）；
    如果（选项）{
      让键；
      对于（输入选项）{
        如果 (选项[key] != null) {
          当前选项[键] = 选项[键];
        }
      }
    }
    {
      如果 (!currentOptions.decodeEntities) {
        抛出新的错误（
          `[@vue/compiler-core] 在浏览器构建中需要decodeEntities选项。`
        （英文）：
      }
    }
    tokenizer.mode = currentOptions.parseMode ===“html”？ 1：currentOptions.parseMode ===“sfc”？ 2：0；
    tokenizer.inXML = currentOptions.ns === 1 || currentOptions.ns === 2;
    const 分隔符 = 选项 && 选项.分隔符;
    if（分隔符）{
      tokenizer.delimiterOpen = toCharCodes(分隔符[0]);
      tokenizer.delimiterClose = toCharCodes(分隔符[1]);
    }
    const 根 = currentRoot = createRoot([]，输入);
    tokenizer.解析（当前输入）；
    root.loc = getLoc(0，输入.长度);
    root.children = 压缩白色空间(root.children);
    当前根 = 空；
    返回根；
  }

  函数 cacheStatic (root，context) {
    走（
      根，
      无效 0，
      语境，
      // 不幸的是，由于潜在的父节点，根节点无法提升
      // 失败属性。
      isSingleElementRoot(根, root.children[0])
    （英文）：
  }
  函数 isSingleElementRoot(root，child) {
    const { 子代 } = 根；
    返回 children.length === 1 && child.type === 1 && !isSlotOutlet(child);
  }
  函数 walk(节点，父节点，上下文，doNotHoistNode = false，inFor = false) {
    const { children } = 节点；
    const toCache = [];
    对于（让 i = 0; i < children.length; i++）{
      const 孩子 = 孩子[i];
      如果 (child.type === 1 && child.tagType === 0) {
        const constantType = doNotHoistNode ? 0 : getConstantType(child, context);
        如果 (常量类型 > 0) {
          如果 (常量类型 >= 2) {
            子节点.codegenNode.patchFlag = -1;
            推送（子）;
            继续;
          }
        } 别的 {
          const codegenNode = child.codegenNode;
          如果 (codegenNode.type === 13) {
            const 标志 = codegenNode.patchFlag;
            如果 ((flag === void 0 || flag === 512 || flag === 1) && getGeneratedPropsConstantType(child，context) >= 2) {
              const props = getNodeProps(child);
              如果（道具）{
                codegenNode.props = 上下文.提升(props);
              }
            }
            如果（codegenNode.dynamicProps）{
              codegenNode.dynamicProps = 上下文.提升(codegenNode.dynamicProps);
            }
          }
        }
      } 否则，如果 (child.type === 12) {
        const constantType = doNotHoistNode ? 0 : getConstantType(child, context);
        如果 (常量类型 >= 2) {
          推送（子）;
          继续;
        }
      }
      如果 (child.type === 1) {
        const isComponent = child.tagType === 1;
        如果（是组件）{
          上下文.范围.vSlot++；
        }
        步行（孩子，节点，上下文，false，inFor）;
        如果（是组件）{
          上下文.范围.vSlot--；
        }
      } 否则，如果 (child.type === 11) {
        步行（孩子，节点，上下文，child.children.length === 1，true）;
      } 否则，如果 (child.type === 9) {
        对于（让 i2 = 0; i2 < child.branches.length; i2++）{
          走（
            子.分支[i2]，
            节点，
            语境，
            子节点.branches[i2].children.length === 1,
            为
          （英文）：
        }
      }
    }
    让 cachedAsArray = false;
    如果 (toCache.length === children.length && node.type === 1) {
      如果 (node.tagType === 0 && node.codegenNode && node.codegenNode.type === 13 && isArray(node.codegenNode.children)) {
        节点.codegenNode.children = getCacheExpression(
          创建数组表达式（node.codegenNode.children）
        （英文）：
        缓存数组 = true;
      } 否则，如果 (node.tagType === 1 && node.codegenNode && node.codegenNode.type === 13 && node.codegenNode.children && ！isArray(node.codegenNode.children) && node.codegenNode.children.type === 15) {
        const slot = getSlotNode(node.codegenNode， "默认");
        如果（槽）{
          slot.returns = getCacheExpression(
            创建数组表达式（slot.returns）
          （英文）：
          缓存数组 = true;
        }
      } 否则，如果 (node.tagType === 3 && 父级 && 父级.type === 1 && 父级.tagType === 1 && 父级.codegenNode && 父级.codegenNode.type === 13 && 父级.codegenNode.children && ！isArray(父级.codegenNode.children) && 父级.codegenNode.children.type === 15) {
        const slotName = findDir(节点，“slot”, true);
        const slot = slotName && slotName.arg && getSlotNode(parent.codegenNode, slotName.arg);
        如果（槽）{
          slot.returns = getCacheExpression(
            创建数组表达式（slot.returns）
          （英文）：
          缓存数组 = true;
        }
      }
    }
    如果 (!cachedAsArray) {
      对于（toCache 的 const 子级）{
        子节点.codegenNode = 上下文.缓存(子节点.codegenNode);
      }
    }
    函数 getCacheExpression（值）{
      const exp = context.cache(值);
      如果（inFor && context.hmr）{
        exp.needArraySpread = true;
      }
      返回 exp；
    }
    函数 getSlotNode(node2，名称) {
      如果 (node2.children && !isArray(node2.children) && node2.children.type === 15) {
        const slot = node2.children.properties.find(
          (p) => p.key === 名称 || p.key.content === 名称
        （英文）：
        返回 slot && slot.value;
      }
    }
    如果（toCache.length && context.transformHoist）{
      context.transformHoist（子级，上下文，节点）；
    }
  }
  函数 getConstantType (节点，上下文) {
    const { constantCache } = 上下文；
    切换（节点.类型）{
      情况 1：
        如果 (节点.tagType !== 0) {
          返回0；
        }
        const 缓存 = constantCache.get(节点);
        如果（缓存！== void 0）{
          返回缓存；
        }
        const codegenNode = 节点.codegenNode;
        如果 (codegenNode.type !== 13) {
          返回0；
        }
        if (codegenNode.isBlock && node.tag !== "svg" && node.tag !== "foreignObject" && node.tag !== "math") {
          返回0；
        }
        如果 (codegenNode.patchFlag === void 0) {
          让 returnType2 = 3;
          const generatedPropsType = getGeneratedPropsConstantType(节点，上下文);
          如果 (generatedPropsType === 0) {
            constCache.set（节点， 0）；
            返回0；
          }
          如果 (generatedPropsType < returnType2) {
            返回类型2 = 生成的属性类型；
          }
          对于（让 i = 0; i < node.children.length; i++）{
            const childType = getConstantType(节点.children[i]，上下文);
            如果 (childType === 0) {
              constCache.set（节点， 0）；
              返回0；
            }
            如果 (childType < returnType2) {
              返回类型2 = 子类型；
            }
          }
          如果 (returnType2 > 1) {
            对于（让 i = 0; i < node.props.length; i++）{
              const p = 节点.props[i];
              如果 (p.type === 7 && p.name === “bind” && p.exp) {
                const expType = getConstantType(p.exp，context);
                如果 (expType === 0) {
                  constCache.set（节点， 0）；
                  返回0；
                }
                如果 (expType < returnType2) {
                  返回类型2 = 表达式类型;
                }
              }
            }
          }
          如果（codegenNode.isBlock）{
            对于（让 i = 0; i < node.props.length; i++）{
              const p = 节点.props[i];
              如果 (p.type === 7) {
                constCache.set（节点， 0）；
                返回0；
              }
            }
            上下文.removeHelper（OPEN_BLOCK）；
            上下文.removeHelper（
              获取VNodeBlockHelper（context.inSSR，codegenNode.isComponent）
            （英文）：
            codegenNode.isBlock = false;
            context.helper(getVNodeHelper(context.inSSR，codegenNode.isComponent));
          }
          constantCache.set（节点，returnType2）；
          返回返回类型2；
        } 别的 {
          constCache.set（节点， 0）；
          返回0；
        }
      情况 2：
      案例 3：
        返回3；
      案例9：
      案例11：
      案例10：
        返回0；
      案例5：
      案例12：
        返回 getConstantType(node.content, context);
      案例4：
        返回节点.constType；
      案例8：
        让返回类型 = 3;
        对于（让 i = 0; i < node.children.length; i++）{
          const child = 节点.children[i];
          如果 (isString(child) || isSymbol(child)) {
            继续;
          }
          const childType = getConstantType(child，context);
          如果 (childType === 0) {
            返回0；
          } 否则，如果 (childType < returnType) {
            返回类型 = 子类型；
          }
        }
        返回返回类型；
      案例20：
        返回2；
      默认：
        返回0；
    }
  }
  const allowHoistedHelperSet = /* @__PURE__ */ new Set([
    规范化_类，
    规范化_样式，
    规范化_属性，
    GUARD_REACTIVE_PROPS
  ]);
  函数 getConstantTypeOfHelperCall (值，上下文) {
    if (value.type === 14 && !isString(value.callee) && allowedHoistedHelperSet.has(value.callee)) {
      const arg = 值.参数[0];
      如果 (arg.type === 4) {
        返回 getConstantType(arg, context);
      } 否则，如果 (arg.type === 14) {
        返回 getConstantTypeOfHelperCall(arg, context);
      }
    }
    返回0；
  }
  函数 getGeneratedPropsConstantType (节点，上下文) {
    让返回类型 = 3;
    const props = getNodeProps(节点);
    如果 (props && props.type === 15) {
      const { 属性 } = props;
      对于（让 i = 0；i < 属性.length；i++）{
        const { 键，值 } = 属性[i];
        const 键类型 = 获取常量类型 (键，上下文)；
        如果 (keyType === 0) {
          返回键类型；
        }
        如果 (键类型 < 返回类型) {
          返回类型 = 键类型；
        }
        让值类型；
        如果 (值.类型 === 4) {
          值类型 = 获取常量类型 (值，上下文)；
        } 否则，如果 (value.type === 14) {
          值类型 = 获取常量类型帮助器调用 (值，上下文)；
        } 别的 {
          值类型 = 0;
        }
        如果 (valueType === 0) {
          返回值类型；
        }
        如果 (值类型 < 返回类型) {
          返回类型 = 值类型；
        }
      }
    }
    返回返回类型；
  }
  函数 getNodeProps (节点) {
    const codegenNode = 节点.codegenNode;
    如果 (codegenNode.type === 13) {
      返回codegenNode.props；
    }
  }

  函数 createTransformContext（root，{
    文件名 = "",
    前缀标识符 = false，
    hoistStatic = false,
    hmr = false，
    缓存处理程序 = false，
    节点变换 = []，
    指令变换 = {}，
    transformHoist = null,
    isBuiltInComponent = NOOP，
    isCustomElement = NOOP，
    表达式插件 = [],
    范围ID = 空，
    开槽=真，
    ssr = false，
    inSSR = false，
    ssrCssVars = ``，
    bindingMetadata = EMPTY_OBJ，
    内联=假，
    isTS = false，
    onError = defaultOnError，
    onWarn = defaultOnWarn，
    兼容配置
  }）{
    const nameMatch = filename.replace(/\?.*$/, "").match(/([^/\\]+)\.\w+$/);
    const 上下文 = {
      // 选项
      文件名，
      selfName：nameMatch && capitalize（camelize（nameMatch[1]）），
      前缀标识符，
      提升机静态，
      嗯，
      缓存处理程序，
      节点变换，
      指令变换，
      变换提升机，
      是内置组件，
      是自定义元素，
      表达式插件，
      范围ID，
      开槽，
      安全部门监督办公室，
      在SSR中，
      ssrCssVars，
      绑定元数据，
      排队，
      是TS，
      错误发生时，
      警告，
      兼容配置，
      // 状态
      根，
      帮助程序：/*@__PURE__*/new Map()，
      组件：/*@__PURE__*/new Set()，
      指令：/* @__PURE__ */ new Set()，
      提升机：[]，
      进口：[]，
      缓存：[]，
      constantCache：/*@__PURE__*/new WeakMap()，
      温度：0，
      标识符：/*@__PURE__*/Object.create(null)，
      范围：{
        vFor: 0,
        vSlot： 0，
        vPre： 0，
        一次： 0
      }，
      父级：null，
      祖父母：null，
      当前节点：根，
      childIndex: 0,
      inVOnce: false,
      // 方法
      助手（姓名）{
        const count = context.helpers.get(名称) || 0;
        context.helpers.set（名称，计数 + 1）；
        返回名称；
      }，
      删除助手（名称）{
        const count = context.helpers.get(名称);
        如果（计数）{
          const 当前计数 = 计数 - 1;
          如果 (!当前计数) {
            上下文.helpers.删除（名称）；
          } 别的 {
            上下文.帮助器.设置（名称，当前计数）；
          }
        }
      }，
      辅助字符串（名称）{
        返回 `_${helperNameMap[context.helper(name)]}`;
      }，
      替换节点（节点）{
        {
          如果（！上下文.当前节点）{
            抛出新的错误（`被替换的节点已被删除。`）；
          }
          如果（！上下文.父级）{
            抛出新的错误（`无法替换根节点。`）；
          }
        }
        context.parent.children[context.childIndex] = context.currentNode = 节点;
      }，
      删除节点（节点）{
        如果（！上下文.父级）{
          抛出新的错误（`无法删除根节点。`）；
        }
        const 列表 = 上下文.父级.子级；
        const removalIndex = 节点？列表.indexOf(节点) : context.currentNode ? context.childIndex : -1;
        如果 (removalIndex < 0) {
          抛出新的错误（`被删除的节点不是当前父节点的子节点`）；
        }
        如果 (!节点 || 节点 === 上下文.当前节点) {
          上下文.当前节点 = 空;
          上下文.onNodeRemoved()；
        } 别的 {
          如果 (context.childIndex > removalIndex) {
            上下文.childIndex--；
            上下文.onNodeRemoved()；
          }
        }
        上下文.父.子级.拼接（removalIndex，1）；
      }，
      onNodeRemoved：NOOP，
      添加标识符（exp）{
      }，
      删除标识符（exp）{
      }，
      提升机（exp）{
        如果 (isString(exp)) exp = createSimpleExpression(exp);
        上下文.提升.推（exp）；
        const 标识符 = createSimpleExpression(
          `_hoisted_${context.hoists.length}`，
          错误的，
          exp.loc，
          2
        （英文）：
        标识符.提升 = exp;
        返回标识符；
      }，
      缓存（exp，isVNode = false，inVOnce = false）{
        const cacheExp = createCacheExpression（
          context.cached.length，
          经验值，
          是VNode，
          因沃
        （英文）：
        上下文.缓存.推送（cacheExp）；
        返回缓存指数；
      }
    };
    返回上下文；
  }
  函数变换（根，选项）{
    const context = createTransformContext(root，选项);
    遍历节点（根，上下文）；
    如果（options.hoistStatic）{
      cacheStatic（根，上下文）；
    }
    如果 (!options.ssr) {
      创建RootCodegen（根，上下文）；
    }
    root.helpers = /* @__PURE__ */ new Set([...context.helpers.keys()]);
    根.组件 = [...上下文.组件];
    根.指令 = [...上下文.指令];
    根.导入 = 上下文.导入；
    根.升降装置 = 上下文.升降装置；
    根.温度=上下文.温度；
    根目录.缓存 = 上下文.缓存;
    根.转换 = true;
  }
  函数 createRootCodegen（root，context）{
    const { 辅助函数 } = 上下文；
    const { 子代 } = 根；
    如果 (children.length === 1) {
      const child = children[0];
      如果（isSingleElementRoot（root，child）&&child.codegenNode）{
        const codegenNode = child.codegenNode;
        如果 (codegenNode.type === 13) {
          convertToBlock（codegenNode，上下文）；
        }
        根.codegenNode = codegenNode;
      } 别的 {
        根.codegenNode = 子节点；
      }
    } 否则，如果 (children.length > 1) {
      让 patchFlag = 64;
      如果 (children.filter((c) => c.type !== 3).length === 1) {
        补丁标志 |= 2048；
      }
      root.codegenNode = createVNodeCall（
        语境，
        助手（片段），
        无效 0，
        根.子代，
        补丁标志，
        无效 0，
        无效 0，
        真的，
        无效 0，
        错误的
      （英文）：
    } 别的 ;
  }
  函数 traverseChildren (parent，context) {
    让 i = 0;
    const nodeRemoved = () => {
      我 - ;
    };
    对于 (; i < 父级.子级.长度; i++) {
      const 子级 = 父级.子级[i];
      如果（isString（child））继续；
      上下文.祖父 = 上下文.父母；
      上下文.父级 = 父级；
      上下文.childIndex = i;
      context.onNodeRemoved = nodeRemoved;
      遍历节点（子节点，上下文）；
    }
  }
  函数遍历节点（节点，上下文）{
    上下文.当前节点 = 节点；
    const { nodeTransforms } = 上下文；
    const exitFns = [];
    对于（让 i2 = 0; i2 < nodeTransforms.length; i2++）{
      const onExit = nodeTransforms[i2](node，context);
      如果（退出时）{
        如果 (isArray (onExit)) {
          exitFns.push（...退出时）；
        } 别的 {
          exitFns.push(退出时);
        }
      }
      如果（！上下文.当前节点）{
        返回;
      } 别的 {
        节点 = 上下文.当前节点；
      }
    }
    切换（节点.类型）{
      案例 3：
        如果 (!context.ssr) {
          上下文.帮助器（创建评论）；
        }
        休息;
      案例5：
        如果 (!context.ssr) {
          上下文.帮助器（TO_DISPLAY_STRING）；
        }
        休息;
      // 对于容器类型，进一步向下遍历
      案例9：
        对于（让 i2 = 0；i2 < 节点.分支.长度；i2++）{
          遍历节点（节点.分支[i2]，上下文）；
        }
        休息;
      案例10：
      案例11：
      情况 1：
      案例 0：
        遍历子节点（节点，上下文）；
        休息;
    }
    上下文.当前节点 = 节点；
    让 i = exitFns.length;
    当 (i--) {
      退出Fns[i]()；
    }
  }
  函数 createStructuralDirectiveTransform (名称，fn) {
    const matches = isString(name) ? (n) => n === name : (n) => name.test(n);
    返回（节点，上下文）=> {
      如果 (节点.类型 === 1) {
        const { props } = 节点；
        如果 (node.tagType === 3 && props.some(isVSlot)) {
          返回;
        }
        const exitFns = [];
        对于（让 i = 0; i < props.length; i++）{
          const prop = props[i];
          如果 (prop.type === 7 && matches(prop.name)) {
            道具.拼接（i，1）；
            我 - ;
            const onExit = fn(节点， prop， 上下文);
            如果（onExit）exitFns.push（onExit）；
          }
        }
        返回 exitFns；
      }
    };
  }

  const PURE_ANNOTATION = `/*@__PURE__*/`;
  const aliasHelper = (s) => `${helperNameMap[s]}: _${helperNameMap[s]}`;
  函数 createCodegenContext（ast，{
    模式 = “功能”，
    prefixIdentifiers = mode === “模块”,
    源地图=假，
    文件名 = `template.vue.html`，
    范围ID = 空，
    优化导入 = false，
    运行时全局名称 = `Vue`,
    运行时模块名称 = `vue`，
    ssrRuntimeModuleName = “vue/server-renderer”,
    ssr = false，
    isTS = false，
    inSSR = false
  }）{
    const 上下文 = {
      模式，
      前缀标识符，
      源地图，
      文件名，
      范围ID，
      优化进口，
      运行时全局名称，
      运行时模块名称，
      ssrRuntimeModule名称，
      安全部门监督办公室，
      是TS，
      在SSR中，
      资料来源：ast.source，
      代码：``，
      列：1，
      行： 1，
      偏移量：0，
      缩进级别： 0，
      纯：假，
      地图：void 0，
      助手（键）{
        返回 `_${helperNameMap[key]}`;
      }，
      推送（代码，newlineIndex = -2 /*无*/，节点）{
        上下文.代码+=代码；
      }，
      缩进（）{
        换行符（++context.indentLevel）；
      }，
      deindent(withoutNewLine = false) {
        如果（无换行符）{
          --上下文.缩进级别；
        } 别的 {
          换行符（--context.indentLevel）；
        }
      }，
      换行符() {
        换行符（上下文.缩进级别）；
      }
    };
    函数换行符（n）{
      context.push("\n" + ` `.repeat(n), 0 /* 开始 */);
    }
    返回上下文；
  }
  函数生成（ast，选项 = {}）{
    const 上下文 = createCodegenContext(ast，选项);
    如果（选项。onContextCreated）选项。onContextCreated（上下文）；
    常量 {
      模式，
      推，
      前缀标识符，
      缩进，
      退缩，
      换行符，
      范围ID，
      苏维埃社会主义共和国
    } = 上下文；
    const helpers = Array.from(ast.helpers);
    const hasHelpers = helpers.length > 0;
    const useWithBlock = !prefixIdentifiers && mode !== “module”;
    const preambleContext = context;
    {
      genFunctionPreamble（ast，preambleContext）；
    }
    const 函数名称 = ssr ? `ssrRender` : `render`;
    const args = ssr ? ["_ctx", "_push", "_parent", "_attrs"] : ["_ctx", "_cache"];
    const 签名 = args.join(", ");
    {
      推送（`函数${functionName}（${signature}）{`）；
    }
    缩进（）；
    如果（useWithBlock）{
      推送（`使用（_ctx）{`）；
      缩进（）；
      如果 (有助手) {
        推（
          `const { ${helpers.map(aliasHelper).join(", ")} } = _Vue
`，
          -1 /* 结束 */
        （英文）：
        换行符（）；
      }
    }
    如果 (ast.components.length) {
      genAssets（ast.components，“组件”，上下文）；
      如果 (ast.directives.length || ast.temps > 0) {
        换行符（）；
      }
    }
    如果 (ast.directives.length) {
      genAssets（ast.directives，“指令”，上下文）；
      如果 (ast.temps > 0) {
        换行符（）；
      }
    }
    如果 (ast.temps > 0) {
      推（`let`）；
      对于（让 i = 0；i < ast.temps；i++）{
        推送（`${i > 0 ? `, ` : ``}_temp${i}`）；
      }
    }
    如果 (ast.components.length || ast.directives.length || ast.temps) {
      推（`
`, 0 /* 开始 */);
      换行符（）；
    }
    如果（！ssr）{
      推送（`返回`）；
    }
    如果（ast.codegenNode）{
      genNode（ast.codegenNode，上下文）；
    } 别的 {
      推（`null`）；
    }
    如果（useWithBlock）{
      去除缩进（）；
      推（`}`）；
    }
    去除缩进（）；
    推（`}`）；
    返回 {
      ast，
      代码：context.code，
      序言：``，
      映射：context.map？context.map.toJSON（）：void 0
    };
  }
  函数 genFunctionPreamble(ast，context) {
    常量 {
      安全部门监督办公室，
      前缀标识符，
      推，
      换行符，
      运行时模块名称，
      运行时全局名称，
      ssrRuntimeModule名称
    } = 上下文；
    const VueBinding = 运行时全局名称;
    const helpers = Array.from(ast.helpers);
    如果 (helpers.length > 0) {
      {
        推（`const _Vue = ${VueBinding}
`, -1 /* 结束 */);
        如果 (ast.hoists.length) {
          const 静态Helpers = [
            创建VNODE，
            创建元素虚拟节点，
            创建评论，
            创建文本，
            创建静态
          ].filter((helper) => helpers.includes(helper)).map(aliasHelper).join(", ");
          推送（`const { ${staticHelpers} } = _Vue
`, -1 /* 结束 */);
        }
      }
    }
    genHoists（ast.hoists，上下文）；
    换行符（）；
    推送（`返回`）；
  }
  函数 genAssets（资产，类型，{助手，推送，换行符，isTS}）{
    const 解析器 = 辅助函数（
      类型 === “组件” ? RESOLVE_COMPONENT : RESOLVE_DIRECTIVE
    （英文）：
    对于（让 i = 0; i < 资产.长度; i++）{
      让 id = 资产[i];
      const maybeSelfReference = id.endsWith("__self");
      如果（可能是自我引用）{
        id = id.切片(0，-6);
      }
      推（
        `const ${toValidAssetId(id，type)} = ${resolver}(${JSON.stringify(id)}${maybeSelfReference？`，true`：``})${isTS？`！`：``}`
      （英文）：
      如果 (i < 资产长度 - 1) {
        换行符（）；
      }
    }
  }
  函数 genHoists (hoists，context) {
    如果 (!提升机.长度) {
      返回;
    }
    上下文.pure = true;
    const { push，换行符} = 上下文；
    换行符（）；
    对于（让 i = 0; i < hoists.length; i++）{
      const exp = 提升机[i];
      如果（表达式）{
        推送（`const _hoisted_${i + 1} = `）；
        genNode（exp，上下文）；
        换行符（）；
      }
    }
    上下文.pure = false;
  }
  函数 isText（n）{
    返回 isString(n) || n.type === 4 || n.type === 2 || n.type === 5 || n.type === 8;
  }
  函数 genNodeListAsArray(节点，上下文) {
    const 多行 = 节点.长度 > 3 || 节点.一些((n) => isArray(n) || !isText(n));
    上下文.推送（`[`）；
    多行 && 上下文.缩进();
    genNodeList（节点，上下文，多线）；
    多行 && context.deindent();
    上下文.推（`]`）；
  }
  函数 genNodeList(节点，上下文，多行 = false，逗号 = true) {
    const { push，换行符} = 上下文；
    对于（让 i = 0; i < 节点.长度; i++）{
      const 节点 = 节点[i];
      如果 (isString(节点)) {
        推送（节点，-3/*未知*/）；
      } 否则，如果 (isArray (节点)) {
        genNodeListAsArray（节点，上下文）；
      } 别的 {
        genNode（节点，上下文）；
      }
      如果 (i < 节点.长度 - 1) {
        如果（多行）{
          逗号&&推（“，”）；
          换行符（）；
        } 别的 {
          逗号&&推（“，”）；
        }
      }
    }
  }
  函数 genNode (节点，上下文) {
    如果 (isString(节点)) {
      context.push(节点，-3/*未知*/);
      返回;
    }
    如果（isSymbol（节点））{
      上下文.推（上下文.助手（节点））；
      返回;
    }
    切换（节点.类型）{
      情况 1：
      案例9：
      案例11：
        断言（
          节点.codegenNode != null,
          “元素/if/for 节点缺少 Codegen 节点。请先应用适当的转换。”
        （英文）：
        genNode（节点.codegenNode，上下文）；
        休息;
      情况 2：
        genText（节点，上下文）；
        休息;
      案例4：
        genExpression（节点，上下文）；
        休息;
      案例5：
        genInterpolation（节点，上下文）；
        休息;
      案例12：
        genNode（节点.codegenNode，上下文）；
        休息;
      案例8：
        genCompoundExpression（节点，上下文）；
        休息;
      案例 3：
        genComment（节点，上下文）；
        休息;
      案例13：
        genVNodeCall（节点，上下文）；
        休息;
      案例14：
        genCallExpression（节点，上下文）；
        休息;
      案例15：
        genObjectExpression（节点，上下文）；
        休息;
      案例17：
        genArrayExpression（节点，上下文）；
        休息;
      案例18：
        genFunctionExpression（节点，上下文）；
        休息;
      案例19：
        genConditionalExpression（节点，上下文）；
        休息;
      案例20：
        genCacheExpression（节点，上下文）；
        休息;
      案例21：
        genNodeList（节点.body，上下文，true，false）；
        休息;
      // SSR 仅限类型
      案例22：
        休息;
      案例23：
        休息;
      案例24：
        休息;
      案例25：
        休息;
      案例26：
        休息;
      /* v8 忽略开始 */
      案例10：
        休息;
      默认：
        {
          断言（false，`未处理的代码生成节点类型：${node.type}`）；
          const exhaustiveCheck = 节点；
          返回穷举检查；
        }
    }
  }
  函数 genText (节点，上下文) {
    context.push(JSON.stringify(node.content), -3 /* 未知 */, node);
  }
  函数 genExpression（节点，上下文）{
    const { 内容， isStatic } = 节点；
    上下文.推送（
      isStatic ? JSON.stringify(content) : 内容，
      -3/*未知*/，
      节点
    （英文）：
  }
  函数 genInterpolation (节点，上下文) {
    const { push, helper, pure } = 上下文；
    如果（纯）推（PURE_ANNOTATION）；
    推送（`${helper（TO_DISPLAY_STRING）}（`）；
    genNode（节点.内容，上下文）；
    推（`）`）;
  }
  函数 genCompoundExpression（节点，上下文）{
    对于（让 i = 0; i < node.children.length; i++）{
      const child = 节点.children[i];
      如果 (isString(child)) {
        context.push（child，-3/*未知*/）；
      } 别的 {
        genNode（子节点， 上下文）；
      }
    }
  }
  函数 genExpressionAsPropertyKey (节点，上下文) {
    const { 推送 } = 上下文；
    如果 (节点类型 === 8) {
      推（`[`）；
      genCompoundExpression（节点，上下文）；
      推（`]`）；
    } 否则，如果 (node.isStatic) {
      const text = isSimpleIdentifier(node.content) ? node.content : JSON.stringify(node.content);
      推送（文本，-2 /*无*/，节点）；
    } 别的 {
      推送（`[${node.content}]`，-3 /* 未知 */，节点）；
    }
  }
  函数 genComment (节点，上下文) {
    const { push, helper, pure } = 上下文；
    如果（纯）{
      推送（PURE_ANNOTATION）；
    }
    推（
      `${helper(CREATE_COMMENT)}(${JSON.stringify(node.content)})`，
      -3/*未知*/，
      节点
    （英文）：
  }
  函数 genVNodeCall(节点，上下文) {
    const { push, helper, pure } = 上下文；
    常量 {
      标签，
      道具，
      孩子们，
      补丁标志，
      dynamicProps，
      指令，
      是块，
      禁用跟踪，
      是组件
    } = 节点；
    让 patchFlagString；
    如果 (补丁标志) {
      {
        如果 (补丁标志 < 0) {
          patchFlagString = patchFlag + `/* ${PatchFlagNames[patchFlag]} */`;
        } 别的 {
          const flagNames = Object.keys(PatchFlagNames).map(Number).filter((n) => n > 0 && patchFlag & n).map((n) => PatchFlagNames[n]).join(`, `);
          patchFlagString = patchFlag + ` /* ${flagNames} */`;
        }
      }
    }
    if（指令）{
      推送（助手（WITH_DIRECTIVES）+`（`）；
    }
    如果 (是块) {
      推送（`（${helper（OPEN_BLOCK）}（${disableTracking？`true`：``}），`）；
    }
    如果（纯）{
      推送（PURE_ANNOTATION）；
    }
    const callHelper = isBlock ? getVNodeBlockHelper(context.inSSR, isComponent) : getVNodeHelper(context.inSSR, isComponent);
    推送（helper（callHelper）+`（`，-2 /*无*/，节点）；
    生成节点列表（
      genNullableArgs（[tag，props，children，patchFlagString，dynamicProps]），
      语境
    （英文）：
    推（`）`）;
    如果 (是块) {
      推（`）`）;
    }
    if（指令）{
      推（`，`）；
      genNode（指令，上下文）；
      推（`）`）;
    }
  }
  函数 genNullableArgs（args）{
    让 i = args.length;
    当 (i--) {
      如果（args[i] != null）中断；
    }
    返回 args.slice(0, i + 1).map((arg) => arg || `null`);
  }
  函数 genCallExpression（节点，上下文）{
    const { push, helper, pure } = 上下文；
    const 被调用者 = isString(node.callee) ？节点.被调用者：助手（节点.被调用者）；
    如果（纯）{
      推送（PURE_ANNOTATION）；
    }
    推送（被调用者 + `（`，-2 /* 无 */，节点）；
    genNodeList（节点.参数，上下文）；
    推（`）`）;
  }
  函数 genObjectExpression（节点，上下文）{
    const { 推送， 缩进， 取消缩进， 换行 } = 上下文；
    const { 属性 } = 节点；
    如果（！properties.length）{
      推送（`{}`，-2 /*无*/，节点）；
      返回;
    }
    const 多行 = properties.length > 1 || properties.some((p) => p.value.type !== 4);
    推送（多行？`{`：`{`）；
    多行 && 缩进();
    对于（让 i = 0；i < 属性.length；i++）{
      const { 键，值 } = 属性[i];
      genExpressionAsPropertyKey（键，上下文）；
      推（`：`）；
      genNode（值，上下文）；
      如果 (i < 属性.长度 - 1) {
        推（`，`）；
        换行符（）；
      }
    }
    多行 && 取消缩进()；
    推送（多行？'}'：'}'）；
  }
  函数 genArrayExpression（节点，上下文）{
    genNodeListAsArray（节点.元素，上下文）；
  }
  函数 genFunctionExpression（节点，上下文）{
    const { 推送， 缩进， 取消缩进 } = 上下文；
    const { 参数， 返回， 主体， 换行符， isSlot } = 节点；
    如果（是Slot）{
      推送（`_${helperNameMap[WITH_CTX]}（`）；
    }
    推送（`（`，-2 /*无*/，节点）；
    如果 (isArray (参数)) {
      genNodeList（参数，上下文）；
    } 否则，如果（参数）{
      genNode（参数，上下文）；
    }
    推送（`）=>`）；
    如果（换行符 || 正文）{
      推（`{`）；
      缩进（）；
    }
    如果（返回）{
      如果（换行符）{
        推送（`返回`）；
      }
      如果（isArray（返回））{
        genNodeListAsArray（返回，上下文）；
      } 别的 {
        genNode（返回，上下文）；
      }
    } 否则，如果（主体）{
      genNode（主体，上下文）；
    }
    如果（换行符 || 正文）{
      去除缩进（）；
      推（`}`）；
    }
    如果（是Slot）{
      推（`）`）;
    }
  }
  函数 genConditionalExpression（节点，上下文）{
    const { 测试，结果，替代，换行符：需要新行 } = 节点；
    const { 推送， 缩进， 取消缩进， 换行 } = 上下文；
    如果 (测试类型 === 4) {
      const needsParens = !isSimpleIdentifier(test.content);
      需要括号 && push(`(`);
      genExpression（测试，上下文）；
      需要括号 && push(`)`);
    } 别的 {
      推（`（`）；
      genNode（测试，上下文）；
      推（`）`）;
    }
    需要换行符 && 缩进();
    上下文.缩进级别++；
    需要换行符 || 推（` `）；
    推（`？`）；
    genNode（结果，上下文）；
    上下文.缩进级别--;
    需要换行符 && 换行符()；
    需要换行符 || 推（` `）；
    推（`：`）；
    const isNested = alternative.type === 19;
    如果 (!isNested) {
      上下文.缩进级别++；
    }
    genNode（替代，上下文）；
    如果 (!isNested) {
      上下文.缩进级别--;
    }
    需要换行符 && 取消缩进(
      真的
      /* 没有换行符 */
    （英文）：
  }
  函数 genCacheExpression（节点，上下文）{
    const { push, helper, indent, deindent, newline } = context;
    const { needPauseTracking，needArraySpread} = 节点；
    如果 (需要ArraySpread) {
      推（`[...（`）；
    }
    推送（`_cache[${node.index}] ||（`）；
    如果（需要暂停跟踪）{
      缩进（）；
      推送（`${helper（SET_BLOCK_TRACKING）}（-1`）；
      如果（node.inVOnce）推送（`，true`）；
      推（'），'）;
      换行符（）；
      推（`（`）；
    }
    推送（`_cache[${node.index}] = `）；
    genNode（节点.值，上下文）；
    如果（需要暂停跟踪）{
      推送（`）。cacheIndex = ${node.index}，`）；
      换行符（）；
      推送（`${helper（SET_BLOCK_TRACKING）}（1），`）；
      换行符（）；
      推送（`_cache[${node.index}]`）；
      去除缩进（）；
    }
    推（`）`）;
    如果 (需要ArraySpread) {
      推（`）]`）;
    }
  }

  const bannedKeywordRE = new RegExp(
    “\\b”+“参数、等待、中断、案例、捕获、类、const、继续、调试器、默认、删除、执行、其他、导出、扩展、最后、对于、函数、如果、导入、让、新、返回、超级、开关、抛出、尝试、var、void、而、使用、收益”。拆分（“，”）。加入（“\\b|\\b”）+“\\b”
  （英文）：
  const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
  函数validateBrowserExpression（节点，上下文，asParams = false，asRawStatements = false）{
    const exp = 节点.内容;
    如果 (!exp.trim()) {
      返回;
    }
    尝试 {
      新函数（
        asRawStatements ? ` ${exp} ` : `返回 ${asParams ? `(${exp}) => {}` : `(${exp})`}`
      （英文）：
    } 捕获（e）{
      让消息 = e.消息；
      const keywordMatch = exp.replace(stripStringRE，“”).match(prohibitedKeywordRE);
      如果（关键字匹配）{
        message = `避免使用 JavaScript 关键字作为属性名称：“${keywordMatch[0]}”`;
      }
      context.onError（
        创建编译器错误（
          45岁，
          节点.loc，
          无效 0，
          信息
        ）
      （英文）：
    }
  }

  const transformExpression = (节点，上下文) => {
    如果 (节点类型 === 5) {
      节点.内容 = 过程表达式（
        节点.内容，
        语境
      （英文）：
    } 否则，如果 (节点类型 === 1) {
      const memo = findDir(node，“备忘录”);
      对于（让 i = 0; i < node.props.length; i++）{
        const dir = 节点.props[i];
        如果 (dir.type === 7 && dir.name !== “for”) {
          const exp = dir.exp;
          const arg = dir.arg;
          if (exp && exp.type === 4 && !(dir.name === "on" && arg) && // key 已在 transformFor(vMemo + vFor) 中处理
          ！（备忘录&& arg && arg.type === 4 && arg.content === “key”））{
            dir.exp = 过程表达式(
              经验值，
              语境，
              // 插槽参数必须作为函数参数进行处理
              dir.name ===“插槽”
            （英文）：
          }
          如果 (arg && arg.type === 4 && !arg.isStatic) {
            dir.arg = 过程表达式(arg，上下文);
          }
        }
      }
    }
  };
  函数 processExpression（节点，上下文，asParams = false，asRawStatements = false，localVars = Object.create（context.identifiers））{
    {
      {
        验证浏览器表达式（节点，上下文，asParams，asRawStatements）；
      }
      返回节点；
    }
  }

  const transformIf = createStructuralDirectiveTransform（
    /^(如果|否则|否则如果)$/，
    (节点，目录，上下文) => {
      返回 processIf(node, dir, context, (ifNode, branch, isRoot) => {
        const 兄弟姐妹 = 上下文.父母.孩子;
        让 i = 兄弟姐妹.indexOf(ifNode);
        让键= 0；
        当 (i-- >= 0) {
          const 兄弟姐妹 = 兄弟姐妹[i];
          如果 (兄弟姐妹 && 兄弟姐妹.类型 === 9) {
            键 += 兄弟.分支.长度；
          }
        }
        返回 () => {
          如果（isRoot）{
            如果Node.codegenNode = createCodegenNodeForBranch（
              分支，
              钥匙，
              语境
            （英文）：
          } 别的 {
            const parentCondition = getParentCondition(ifNode.codegenNode);
            parentCondition.alternate = createCodegenNodeForBranch（
              分支，
              键 + ifNode.branches.length - 1，
              语境
            （英文）：
          }
        };
      });
    }
  （英文）：
  函数 processIf(节点，目录，上下文，processCodegen) {
    如果 (dir.name !== “else” && (!dir.exp || !dir.exp.content.trim())) {
      const loc = dir.exp ? dir.exp.loc : 节点.loc;
      context.onError（
        createCompilerError（28，dir.loc）
      （英文）：
      dir.exp = createSimpleExpression(`true`, false, loc);
    }
    如果 (目录.exp) {
      验证浏览器表达式（dir.exp，上下文）；
    }
    如果（dir.name ===“如果”）{
      const branch = createIfBranch (节点， 目录);
      const ifNode = {
        类型： 9，
        loc: cloneLoc(node.loc),
        分支：[分支]
      };
      上下文.replaceNode（如果是Node）；
      如果（processCodegen）{
        返回 processCodegen(ifNode, branch, true);
      }
    } 别的 {
      const 兄弟姐妹 = 上下文.父母.孩子;
      const 注释 = [];
      让 i = 兄弟姐妹.indexOf(节点);
      当 (i-- >= -1) {
        const 兄弟姐妹 = 兄弟姐妹[i];
        如果 (兄弟姐妹 && 兄弟姐妹.类型 === 3) {
          上下文.删除节点（兄弟）；
          评论.unshift（兄弟）；
          继续;
        }
        如果 (兄弟 && 兄弟.类型 === 2 && !兄弟.内容.trim().长度) {
          上下文.删除节点（兄弟）；
          继续;
        }
        如果 (兄弟姐妹 && 兄弟姐妹.类型 === 9) {
          如果 (dir.name === “else-if” && brothers.branches[sibling.branches.length - 1].condition === void 0) {
            context.onError（
              createCompilerError（30，node.loc）
            （英文）：
          }
          上下文.删除节点（）；
          const branch = createIfBranch (节点， 目录);
          if (comments.length && // #3619 如果 v-if 是 <transition> 的直接子项，则忽略注释
          !(context.parent && context.parent.type === 1 && (context.parent.tag === “transition” || context.parent.tag === “Transition”))) {
            分支.children = [...评论，...分支.children];
          }
          {
            const 键 = 分支.userKey;
            如果（键）{
              兄弟.分支.forEach(({ 用户密钥 }) => {
                如果 (isSameKey(用户密钥，密钥)) {
                  context.onError（
                    创建编译器错误（
                      29，
                      分支.用户密钥.loc
                    ）
                  （英文）：
                }
              });
            }
          }
          兄弟.分支.推（分支）；
          const onExit = processCodegen && processCodegen(sibling，branch，false);
          遍历节点（分支，上下文）；
          如果（onExit）onExit（）;
          上下文.当前节点 = 空;
        } 别的 {
          context.onError（
            createCompilerError（30，node.loc）
          （英文）：
        }
        休息;
      }
    }
  }
  函数 createIfBranch (节点，目录) {
    const isTemplateIf = node.tagType === 3;
    返回 {
      类型： 10，
      loc：节点.loc，
      条件： dir.name === "else" ? void 0 : dir.exp,
      子节点：isTemplateIf && !findDir(node, "for") ?node.children : [node],
      userKey: findProp(节点，`key`)，
      是否为模板
    };
  }
  函数 createCodegenNodeForBranch（分支，keyIndex，上下文）{
    如果（分支条件）{
      返回创建条件表达式（
        分支.条件,
        createChildrenCodegenNode（分支，keyIndex，上下文），
        // 确保传入 asBlock: true 以便注释节点调用
        // 关闭当前块。
        创建调用表达式（context.helper（CREATE_COMMENT），[
          '“v-if”'，
          “真的”
        ]）
      （英文）：
    } 别的 {
      返回 createChildrenCodegenNode(branch, keyIndex, context);
    }
  }
  函数 createChildrenCodegenNode（分支，keyIndex，上下文）{
    const { 辅助函数 } = 上下文；
    const keyProperty = createObjectProperty（
      `key`，
      创建简单表达式（
        `${keyIndex}`，
        错误的，
        locStub，
        2
      ）
    （英文）：
    const { 子级 } = 分支；
    const firstChild = children[0];
    const needFragmentWrapper = children.length !== 1 || firstChild.type !== 1;
    如果 (需要FragmentWrapper) {
      如果 (children.length === 1 && firstChild.type === 11) {
        const vnodeCall = firstChild.codegenNode;
        注入Prop（vnodeCall，keyProperty，上下文）；
        返回 vnodeCall；
      } 别的 {
        让 patchFlag = 64;
        如果 (!branch.isTemplateIf && children.filter((c) => c.type !== 3).length === 1) {
          补丁标志 |= 2048；
        }
        返回 createVNodeCall（
          语境，
          助手（片段），
          创建对象表达式（[keyProperty]），
          孩子们，
          补丁标志，
          无效 0，
          无效 0，
          真的，
          错误的，
          错误的，
          分支位置
        （英文）：
      }
    } 别的 {
      const ret = firstChild.codegenNode;
      const vnodeCall = getMemoedVNodeCall(ret);
      如果 (vnodeCall.type === 13) {
        转换为块（vnodeCall，上下文）；
      }
      注入Prop（vnodeCall，keyProperty，上下文）；
      返回 ret；
    }
  }
  函数 isSameKey(a，b) {
    如果 (!a || a.类型 !== b.类型) {
      返回 false；
    }
    如果 (a.类型 === 6) {
      如果 (a.值.内容 !== b.值.内容) {
        返回 false；
      }
    } 别的 {
      const exp = a.exp;
      const 分支Exp = b.exp;
      如果 (exp.类型 !== branchExp.类型) {
        返回 false；
      }
      如果 (exp.type !== 4 || exp.isStatic !== branchExp.isStatic || exp.content !== branchExp.content) {
        返回 false；
      }
    }
    返回 true；
  }
  函数 getParentCondition(节点) {
    while (真) {
      如果 (节点类型 === 19) {
        如果 (节点.替代.类型 === 19) {
          节点=节点.替代；
        } 别的 {
          返回节点；
        }
      } 否则，如果 (节点类型 === 20) {
        节点=节点.值；
      }
    }
  }

  const transformBind = (dir, _node, context) => {
    const { 修饰符， loc } = dir;
    const arg = dir.arg;
    让 { exp } = dir;
    如果 (exp && exp.type === 4 && !exp.content.trim()) {
      {
        exp = 无效 0;
      }
    }
    如果 (!表达式) {
      如果 (arg.type !== 4 || !arg.isStatic) {
        context.onError（
          创建编译器错误（
            52，
            参数
          ）
        （英文）：
        返回 {
          道具：[
            创建对象属性（arg，createSimpleExpression（"", true，loc））
          ]
        };
      }
      转换绑定简写（目录）；
      exp = 目录.exp;
    }
    如果（arg.类型！== 4）{
      arg.children.unshift(`(`);
      arg.children.push(`) || ""`);
    } 否则，如果（！arg.isStatic）{
      arg.content = `${arg.content} || ""`;
    }
    如果（modifiers.some（（mod）=> mod.content ===“camel”））{
      如果 (arg.type === 4) {
        如果（arg.isStatic）{
          arg.内容 = camelize（arg.内容）；
        } 别的 {
          arg.content = `${context.helperString(CAMELIZE)}(${arg.content})`;
        }
      } 别的 {
        arg.children.unshift(`${context.helperString(CAMELIZE)}(`);
        arg.children.push（`）`）;
      }
    }
    如果（！context.inSSR）{
      如果 (modifiers.some((mod) => mod.content === "prop")) {
        注入前缀（arg， “。”）；
      }
      如果 (modifiers.some((mod) => mod.content === "attr")) {
        注入前缀（arg，“^”）；
      }
    }
    返回 {
      道具：[createObjectProperty（arg，exp）]
    };
  };
  const transformBindShorthand = (dir, context) => {
    const arg = dir.arg;
    const propName = camelize(arg.content);
    dir.exp = 创建简单表达式(propName，false，arg.loc);
  };
  const injectionPrefix = (arg，prefix) => {
    如果 (arg.type === 4) {
      如果（arg.isStatic）{
        arg.内容 = 前缀 + arg.内容;
      } 别的 {
        arg.content = `\`${prefix}\${${arg.content}}\``;
      }
    } 别的 {
      arg.children.unshift(`'${prefix}' + (`);
      arg.children.push（`）`）;
    }
  };

  const transformFor = createStructuralDirectiveTransform（
    “为了”，
    (节点，目录，上下文) => {
      const { helper，removeHelper} = 上下文；
      返回 processFor(node, dir, context, (forNode) => {
        const renderExp = createCallExpression(helper(RENDER_LIST), [
          forNode.source
        ]);
        const isTemplate = isTemplateNode(节点);
        const memo = findDir(node，“备忘录”);
        const keyProp = findProp(node，`key`，false，true);
        const isDirKey = keyProp && keyProp.type === 7;
        如果 (isDirKey && !keyProp.exp) {
          转换绑定简写（keyProp）；
        }
        让 keyExp = keyProp && (keyProp.type === 6 ? keyProp.value ? createSimpleExpression(keyProp.value.content, true) : void 0 : keyProp.exp);
        const keyProperty = keyProp && keyExp ?createObjectProperty(`key`, keyExp) : null;
        const isStableFragment = forNode.source.type === 4 && forNode.source.constType > 0;
        const fragmentFlag = isStableFragment?64: keyProp?128:256;
        forNode.codegenNode = createVNodeCall（
          语境，
          助手（片段），
          无效 0，
          渲染指数，
          fragmentFlag，
          无效 0，
          无效 0，
          真的，
          !是稳定片段，
          错误的，
          节点位置
        （英文）：
        返回 () => {
          让 childBlock；
          const { children } = forNode;
          如果（是模板）{
            节点.子节点.一些((c) => {
              如果 (c.type === 1) {
                const key = findProp(c，“key”);
                如果（键）{
                  context.onError（
                    创建编译器错误（
                      33岁，
                      密钥位置
                    ）
                  （英文）：
                  返回 true；
                }
              }
            });
          }
          const needFragmentWrapper = children.length !== 1 || children[0].type !== 1;
          const slotOutlet = isSlotOutlet(node) ? node : isTemplate && node.children.length === 1 && isSlotOutlet(node.children[0]) ? node.children[0] : null;
          如果 (slotOutlet) {
            childBlock = slotOutlet.codegenNode;
            如果（isTemplate && keyProperty）{
              注入Prop（childBlock，keyProperty，上下文）；
            }
          }否则，如果（需要FragmentWrapper）{
            childBlock = createVNodeCall（
              语境，
              助手（片段），
              keyProperty ? createObjectExpression([keyProperty]) : void 0，
              节点.children，
              64，
              无效 0，
              无效 0，
              真的，
              无效 0，
              错误的
            （英文）：
          } 别的 {
            childBlock = children[0].codegenNode;
            如果（isTemplate && keyProperty）{
              注入Prop（childBlock，keyProperty，上下文）；
            }
            if (childBlock.isBlock !== !isStableFragment) {
              如果 (childBlock.isBlock) {
                删除Helper（OPEN_BLOCK）；
                删除助手（
                  获取VNodeBlockHelper（context.inSSR，childBlock.isComponent）
                （英文）：
              } 别的 {
                删除助手（
                  获取VNodeHelper（context.inSSR，childBlock.isComponent）
                （英文）：
              }
            }
            childBlock.isBlock = !isStableFragment;
            如果 (childBlock.isBlock) {
              助手（OPEN_BLOCK）；
              助手（getVNodeBlockHelper（context.inSSR，childBlock.isComponent））；
            } 别的 {
              助手（getVNodeHelper（context.inSSR，childBlock.isComponent））；
            }
          }
          如果（备忘录）{
            const loop = createFunctionExpression（
              createForLoopParams（forNode.parseResult，[
                创建简单表达式（`_cached`）
              ]）
            （英文）：
            循环.body = createBlockStatement([
              创建复合表达式（[`const _memo = (`, memo.exp, `)`]),
              创建复合表达式([
                `如果（_缓存，
                ...keyExp ? [` && _cached.key === `, keyExp] : [],
                ` && ${context.helperString(
                备注：
              ）（_cached，_memo））返回_cached`
              ]),
              创建复合表达式（[`const _item = `, childBlock]），
              创建简单表达式（`_item.memo = _memo`），
              创建简单表达式（`返回 _item`）
            ]);
            renderExp.arguments.push(
              环形，
              创建简单表达式（`_cache`），
              创建简单表达式（字符串（context.cached.length））
            （英文）：
            上下文.缓存.推送（空）；
          } 别的 {
            renderExp.arguments.push(
              创建函数表达式（
                createForLoopParams（forNode.parseResult），
                childBlock，
                真的
              ）
            （英文）：
          }
        };
      });
    }
  （英文）：
  函数 processFor(节点，目录，上下文，processCodegen) {
    如果 (!dir.exp) {
      context.onError（
        createCompilerError（31，dir.loc）
      （英文）：
      返回;
    }
    const parseResult = dir.forParseResult;
    如果（！解析结果）{
      context.onError（
        createCompilerError（32，dir.loc）
      （英文）：
      返回;
    }
    finalizeForParseResult（parseResult，上下文）；
    const { 添加标识符， 删除标识符， 范围 } = 上下文；
    const { 源，值，键，索引 } = parseResult;
    const forNode = {
      类型： 11，
      loc： dir.loc，
      来源，
      值别名：值，
      keyAlias： key，
      objectIndexAlias：索引，
      解析结果，
      子节点：isTemplateNode(node) ? node.children : [node]
    };
    上下文.replaceNode（forNode）；
    范围.vFor++；
    const onExit = processCodegen && processCodegen(forNode);
    返回 () => {
      范围.vFor--；
      如果（onExit）onExit（）;
    };
  }
  函数 finalizeForParseResult（结果，上下文）{
    如果（result.finalized）返回；
    {
      验证浏览器表达式（结果.源，上下文）；
      如果（结果.键）{
        验证浏览器表达式（
          结果.key，
          语境，
          真的
        （英文）：
      }
      如果（结果.索引）{
        验证浏览器表达式（
          结果.索引，
          语境，
          真的
        （英文）：
      }
      如果（结果.值）{
        验证浏览器表达式（
          结果.值，
          语境，
          真的
        （英文）：
      }
    }
    结果.最终确定 = true;
  }
  函数 createForLoopParams({ 值， 键， 索引 }， memoArgs = []) {
    返回 createParamsList([value, key, index, ...memoArgs]);
  }
  函数 createParamsList（args）{
    让 i = args.length;
    当 (i--) {
      如果（args[i]）中断；
    }
    返回 args.slice(0, i + 1).map((arg, i2) => arg || createSimpleExpression(`_`.repeat(i2 + 1), false));
  }

  const defaultFallback = createSimpleExpression(`undefined`, false);
  const trackSlotScopes = (节点，上下文) => {
    如果 (node.type === 1 && (node.tagType === 1 || node.tagType === 3)) {
      const vSlot = findDir(node，“slot”);
      如果（vSlot）{
        vSlot.exp;
        上下文.范围.vSlot++；
        返回 () => {
          上下文.范围.vSlot--；
        };
      }
    }
  };
  const buildClientSlotFn = (props，_vForExp，children，loc) => createFunctionExpression（
    道具，
    孩子们，
    错误的，
    真的，
    children.length ? children[0].loc : loc
  （英文）：
  函数 buildSlots(节点，上下文，buildSlotFn = buildClientSlotFn) {
    上下文.帮助器（WITH_CTX）；
    const { children， loc } = 节点；
    const slotsProperties = [];
    const dynamicSlots = [];
    让 hasDynamicSlots = context.scopes.vSlot > 0 || context.scopes.vFor > 0;
    const onComponentSlot = findDir(node, "slot", true);
    如果（onComponentSlot）{
      const { arg， exp } = onComponentSlot;
      如果 (arg && !isStaticExp(arg)) {
        有动态槽 = 真；
      }
      slotsProperties.push(
        创建对象属性（
          arg || createSimpleExpression（“默认”，true），
          buildSlotFn（exp，void 0，children，loc）
        ）
      （英文）：
    }
    让 hasTemplateSlots = false;
    让 hasNamedDefaultSlot = false;
    const implicitDefaultChildren = [];
    const seenSlotNames = /* @__PURE__ */ new Set();
    让条件分支索引 = 0；
    对于（让 i = 0; i < children.length; i++）{
      const slotElement = children[i];
      让 slotDir；
      如果 (!isTemplateNode(slotElement) || !(slotDir = findDir(slotElement, "slot", true))) {
        如果 (slotElement.type !== 3) {
          隐式默认子元素。
        }
        继续;
      }
      如果（onComponentSlot）{
        context.onError（
          createCompilerError（37，slotDir.loc）
        （英文）：
        休息;
      }
      有模板槽 = 真;
      const { children：slotChildren， loc：slotLoc } = slotElement;
      常量 {
        参数：slotName = createSimpleExpression（`default`，true），
        exp：slotProps，
        loc： dirLoc
      } = 插槽目录；
      让静态SlotName；
      如果 (isStaticExp(slotName)) {
        静态槽名称 = 槽名称 ? 槽名称.内容 : `默认`;
      } 别的 {
        有动态槽 = 真；
      }
      const vFor = findDir(slotElement，“for”);
      const slotFunction = buildSlotFn(slotProps， vFor， slotChildren， slotLoc);
      让 vIf；
      让 vElse；
      如果 (vIf = findDir(slotElement，“如果”)) {
        有动态槽 = 真；
        dynamicSlots.push(
          创建条件表达式（
            vIf.exp，
            buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++),
            defaultFallback
          ）
        （英文）：
      } 否则，如果（vElse = findDir（
        插槽元素，
        /^else(-if)?$/,
        真的
        /* 允许空 */
      ））{
        让 j = i;
        让上一个；
        当 (j--) {
          上一个 = 子级[j];
          如果（prev.type！== 3）{
            休息;
          }
        }
        如果 (prev && isTemplateNode(prev) && findDir(prev，/^(else-)?if$/)) {
          让条件 = dynamicSlots[dynamicSlots.length - 1];
          while (条件.替代.类型 === 19) {
            条件=条件.替代；
          }
          条件.替代 = vElse.exp ? 创建条件表达式(
            vElse.exp，
            构建动态槽（
              插槽名称，
              槽函数，
              条件分支索引++
            ),
            defaultFallback
          ) : buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++);
        } 别的 {
          context.onError（
            createCompilerError（30，vElse.loc）
          （英文）：
        }
      } 否则，如果 (vFor) {
        有动态槽 = 真；
        const parseResult = vFor.forParseResult;
        如果（解析结果）{
          finalizeForParseResult（parseResult，上下文）；
          dynamicSlots.push(
            创建调用表达式（context.helper（RENDER_LIST），[
              解析结果.源，
              创建函数表达式（
                createForLoopParams（解析结果），
                buildDynamicSlot(slotName, slotFunction),
                真的
              ）
            ]）
          （英文）：
        } 别的 {
          context.onError（
            创建编译器错误（
              32，
              位置变量
            ）
          （英文）：
        }
      } 别的 {
        如果（静态插槽名称）{
          如果 (seenSlotNames.has(staticSlotName)) {
            context.onError（
              创建编译器错误（
                38岁，
                目录位置
              ）
            （英文）：
            继续;
          }
          已看到SlotNames.添加（静态SlotName）；
          如果 (staticSlotName === “默认”) {
            有命名默认槽 = true;
          }
        }
        slotsProperties.push(createObjectProperty(slotName，slotFunction));
      }
    }
    如果 (!onComponentSlot) {
      const buildDefaultSlotProperty = (props，children2) => {
        const fn = buildSlotFn(props， void 0， children2， loc);
        返回 createObjectProperty（`default`，fn）；
      };
      如果 (!hasTemplateSlots) {
        slotsProperties.push(buildDefaultSlotProperty(void 0，children));
      } 否则，如果 (implicitDefaultChildren.length && // #3766
      // 使用 whitespace: 'preserve'，插槽之间的空格将最终出现在
      // implicitDefaultChildren。如果所有隐式子项都是空格，则忽略。
      implicitDefaultChildren.some((node2) => isNonWhitespaceContent(node2))) {
        如果 (hasNamedDefaultSlot) {
          context.onError（
            创建编译器错误（
              39，
              隐式默认儿童[0].loc
            ）
          （英文）：
        } 别的 {
          slotsProperties.push(
            buildDefaultSlotProperty（void 0，implicitDefaultChildren）
          （英文）：
        }
      }
    }
    const slotFlag = hasDynamicSlots？2：有ForwardedSlots（node.children）？3：1；
    让插槽= createObjectExpression（
      slotsProperties.concat（
        创建对象属性（
          `_`，
          // 2 = 已编译但动态 = 可以跳过规范化，但必须运行 diff
          // 1 = 已编译且静态 = 可以跳过规范化和 diff 进行优化
          创建简单表达式（
            slotFlag + (` /* ${slotFlagsText[slotFlag]} */` ),
            错误的
          ）
        ）
      ),
      洛
    （英文）：
    如果 (dynamicSlots.length) {
      插槽 = createCallExpression（context.helper（CREATE_SLOTS），[
        插槽，
        创建数组表达式（动态槽）
      ]);
    }
    返回 {
      插槽，
      有动态槽
    };
  }
  函数 buildDynamicSlot (名称，fn，索引) {
    const props = [
      createObjectProperty（`name`，名称），
      创建对象属性（`fn`，fn）
    ]；
    如果（索引！=空）{
      props.push(
        createObjectProperty（`key`，createSimpleExpression（String（index），true））
      （英文）：
    }
    返回 createObjectExpression（props）；
  }
  函数 hasForwardedSlots(children) {
    对于（让 i = 0; i < children.length; i++）{
      const 孩子 = 孩子[i];
      切换（子类型）{
        情况 1：
          如果 (child.tagType === 2 || hasForwardedSlots(child.children)) {
            返回 true；
          }
          休息;
        案例9：
          如果（hasForwardedSlots（child.branches））返回true；
          休息;
        案例10：
        案例11：
          如果（hasForwardedSlots（child.children））返回true；
          休息;
      }
    }
    返回 false；
  }
  函数 isNonWhitespaceContent（节点）{
    如果 (节点.类型 !== 2 && 节点.类型 !== 12)
      返回 true；
    返回 node.type === 2 ? !!node.content.trim() : isNonWhitespaceContent(node.content);
  }

  const directiveImportMap = /* @__PURE__ */ new WeakMap();
  const transformElement = (节点，上下文) => {
    返回函数 postTransformElement() {
      节点 = 上下文.当前节点；
      如果 (!(node.type === 1 && (node.tagType === 0 || node.tagType === 1))) {
        返回;
      }
      const { 标签， props } = 节点；
      const isComponent = 节点.tagType === 1;
      让 vnodeTag = isComponent ? resolveComponentType(node, context) : `"${tag}"`;
      const isDynamicComponent = isObject(vnodeTag) && vnodeTag.callee === RESOLVE_DYNAMIC_COMPONENT;
      让 vnodeProps；
      让 vnodeChildren；
      让 patchFlag = 0;
      让 vnodeDynamicProps；
      让动态PropNames；
      让 vnodeDirective s；
      让 shouldUseBlock = （
        // 动态组件可能解析为普通元素
        isDynamicComponent || vnodeTag === TELEPORT || vnodeTag === SUSPENSE || !isComponent && // <svg> 和 <foreignObject> 必须强制放入块中，以便块
        // 更新内部在运行时获取正确的 isSVG 标志。（#639，#643）
        // 从技术上讲，这是针对网络的，但将逻辑从核心中分离出来
        // 导致太多不必要的复杂性。
        （标签 === “svg” || 标签 === “foreignObject” || 标签 === “math”）
      （英文）：
      如果 (props.length > 0) {
        const propsBuildResult = buildProps(
          节点，
          语境，
          无效 0，
          是组件，
          是否为动态组件
        （英文）：
        vnodeProps = propsBuildResult.props;
        patchFlag = propsBuildResult.patchFlag;
        动态属性名称 = propsBuildResult.动态属性名称；
        const 指令 = propsBuildResult.directives;
        vnodeDirectives = 指令 && 指令.长度 ? createArrayExpression(
          指令.map((dir) => buildDirectiveArgs(dir，context))
        ）：无效0；
        如果（propsBuildResult.shouldUseBlock）{
          应该使用块 = true;
        }
      }
      如果 (节点.children.length > 0) {
        如果 (vnodeTag === KEEP_ALIVE) {
          应该使用块 = true;
          补丁标志 |= 1024;
          如果 (节点.children.length > 1) {
            context.onError（
              创建编译器错误（46，{
                开始：node.children[0].loc.start，
                结束：节点.children[node.children.length - 1].loc.end，
                来源： ””
              }）
            （英文）：
          }
        }
        const shouldBuildAsSlots = isComponent && // Teleport 不是真正的组件，并且具有专门的运行时处理
        vnodeTag !== TELEPORT && // 如上所述。
        节点标签！==KEEP_ALIVE；
        如果（应该构建插槽）{
          const { 插槽， hasDynamicSlots } = buildSlots（节点， 上下文）；
          vnodeChildren = 插槽；
          如果 (hasDynamicSlots) {
            补丁标志 |= 1024;
          }
        } 否则，如果 (node.children.length === 1 && vnodeTag !== TELEPORT) {
          const child = 节点.children[0];
          const 类型 = child.类型;
          const hasDynamicTextChild = 类型 === 5 || 类型 === 8;
          如果 (hasDynamicTextChild && getConstantType(child，context) === 0) {
            补丁标志 |= 1;
          }
          如果 (hasDynamicTextChild || 类型 === 2) {
            vnodeChildren = 孩子;
          } 别的 {
            vnodeChildren = 节点.children;
          }
        } 别的 {
          vnodeChildren = 节点.children;
        }
      }
      如果 (dynamicPropNames && dynamicPropNames.length) {
        vnodeDynamicProps = stringifyDynamicPropNames(dynamicPropNames);
      }
      节点.codegenNode = createVNodeCall（
        语境，
        vnode标签，
        vnodeProps，
        vnode子节点，
        patchFlag === 0 ? void 0 : patchFlag,
        vnodeDynamicProps，
        vnode指令，
        !!应该使用块，
        错误的，
        是组件，
        节点位置
      （英文）：
    };
  };
  函数 resolveComponentType (节点，上下文，ssr = false) {
    让 { 标签 } = 节点；
    const isExplicitDynamic = isComponentTag(标签);
    const isProp = findProp(
      节点，
      “是”，
      错误的，
      真的
      /* 允许为空 */
    （英文）：
    如果（isProp）{
      如果 (isExplicitDynamic || false) {
        让 exp；
        如果 (isProp.type === 6) {
          exp = isProp.value && 创建简单表达式（isProp.value.content，true）；
        } 别的 {
          exp = isProp.exp;
          如果 (!表达式) {
            exp = createSimpleExpression（`is`，false，isProp.arg.loc）；
          }
        }
        如果（表达式）{
          返回 createCallExpression（context.helper（RESOLVE_DYNAMIC_COMPONENT），[
            经验
          ]);
        }
      } 否则，如果 (isProp.type === 6 && isProp.value.content.startsWith("vue:")) {
        标签 = isProp.value.内容.切片（4）；
      }
    }
    constbuiltIn=isCoreComponent（标签）||context.isBuiltInComponent（标签）；
    如果（内置）{
      如果（！ssr）context.helper（builtIn）；
      返回内置；
    }
    上下文.帮助器（RESOLVE_COMPONENT）；
    上下文.组件.添加（标签）；
    返回ValidAssetId(tag，`component`)；
  }
  函数 buildProps(节点，上下文，props = node.props，isComponent，isDynamicComponent，ssr = false) {
    const { tag，loc：elementLoc，children} = node;
    让属性=[]；
    合并参数
    const 运行时指令 = [];
    const hasChildren = children.length > 0;
    让 shouldUseBlock = false;
    让 patchFlag = 0;
    让 hasRef = false;
    让 hasClassBinding = false;
    让 hasStyleBinding = false;
    让 hasHydrationEventBinding = false;
    让 hasDynamicKeys = false;
    让 hasVnodeHook = false;
    const dynamicPropNames = [];
    const pushMergeArg = (arg) => {
      如果（属性.长度）{
        合并参数.推送（
          创建对象表达式（dedupeProperties（属性），elementLoc）
        （英文）：
        属性=[];
      }
      如果（arg）mergeArgs.push（arg）；
    };
    const pushRefVForMarker = () => {
      如果 (context.scopes.vFor > 0) {
        属性.push(
          创建对象属性（
            创建简单表达式（“ref_for”，true），
            创建简单表达式(“true”)
          ）
        （英文）：
      }
    };
    const analyzePatchFlag = （{ 键， 值 }） => {
      如果 (isStaticExp(key)) {
        const 名称 = 键.内容;
        const isEventHandler = isOn（名称）；
        if (isEventHandler && (!isComponent || isDynamicComponent) && // 省略点击处理程序的标志，因为 hydration 会产生点击
        //专用快速路径。
        name.toLowerCase() !== "onclick" && // 省略 v-model 处理程序
        name !== "onUpdate:modelValue" && // 省略 onVnodeXXX 钩子
        !isReservedProp (名称)) {
          具有HydrationEventBinding = true;
        }
        如果（isEventHandler && isReservedProp（名称））{
          hasVnodeHook = true;
        }
        如果（isEventHandler && value.type === 14）{
          值=值.参数[0]；
        }
        如果 (value.type === 20 || (value.type === 4 || value.type === 8) && getConstantType(value, context) > 0) {
          返回;
        }
        如果 (name === “ref”) {
          hasRef = true;
        }否则，如果（名称===“类”）{
          有ClassBinding = true;
        }否则，如果（名称===“样式”）{
          具有StyleBinding = 真；
        } 否则，如果 (name !== “key” && !dynamicPropNames.includes(name)) {
          dynamicPropNames.push（名称）；
        }
        如果 (isComponent && (name === “class” || name === “style”) && !dynamicPropNames.includes(name)) {
          dynamicPropNames.push（名称）；
        }
      } 别的 {
        有动态键 = 真;
      }
    };
    对于（让 i = 0; i < props.length; i++）{
      const prop = props[i];
      如果 (prop.type === 6) {
        const { loc， 名称， nameLoc， 值 } = prop;
        让 isStatic = true;
        如果 (name === “ref”) {
          hasRef = true;
          推送RefVForMarker（）;
        }
        如果 (name === "is" && (isComponentTag(tag) || 值 && value.content.startsWith("vue:") || false)) {
          继续;
        }
        属性.push(
          创建对象属性（
            创建简单表达式（名称，true，nameLoc），
            创建简单表达式（
              值？值.内容：“”，
              是静态的，
              值 ? 值.loc : loc
            ）
          ）
        （英文）：
      } 别的 {
        const { 名称， 参数， exp， loc， 修饰符 } = prop;
        const isVBind = name === “bind”;
        const isVOn = name === “on”;
        如果 (名称 === “槽”) {
          如果（！是组件）{
            context.onError（
              创建编译器错误（40，loc）
            （英文）：
          }
          继续;
        }
        如果（名称===“once”||名称===“memo”）{
          继续;
        }
        如果 (name === “is” || isVBind && isStaticArgOf(arg，“is”) && (isComponentTag(tag) || false)) {
          继续;
        }
        如果 (isVOn && ssr) {
          继续;
        }
        如果 （
          // #938: 具有动态键的元素应强制放入块中
          isVBind && isStaticArgOf(arg, "key") || // 内联的更新前钩子需要强制阻塞以便调用它
          // 在子项之前
          isVOn && hasChildren && isStaticArgOf(arg, "vue:before-update")
        ）{
          应该使用块 = true;
        }
        如果 (isVBind && isStaticArgOf(arg，"ref")) {
          推送RefVForMarker（）;
        }
        如果 (!arg && (isVBind || isVOn)) {
          有动态键 = 真;
          如果（表达式）{
            如果 (isVBind) {
              推送RefVForMarker（）;
              推送合并参数（）；
              合并Args.推送（exp）；
            } 别的 {
              pushMergeArg（{
                类型：14，
                位置，
                被调用者：context.helper（TO_HANDLERS），
                参数：isComponent？[exp]：[exp，`true`]
              });
            }
          } 别的 {
            context.onError（
              创建编译器错误（
                是否绑定？34 : 35，
                洛
              ）
            （英文）：
          }
          继续;
        }
        如果（isVBind && modifiers.some（（mod）=> mod.content ===“prop”））{
          补丁标志 |= 32;
        }
        const directiveTransform = context.directiveTransforms[name];
        如果（指令变换）{
          const { props： props2， needRuntime } = directiveTransform(prop， node， context);
          ！ssr && props2.forEach（分析PatchFlag）；
          如果（isVOn && arg && ！isStaticExp（arg））{
            推送合并参数（createObjectExpression（props2，elementLoc））；
          } 别的 {
            属性.推（...props2）；
          }
          如果 (需要运行时) {
            运行时指令.推（prop）；
            如果（isSymbol（需要运行时））{
              指令ImportMap.设置（prop，needRuntime）；
            }
          }
        } 否则，如果 (!isBuiltInDirective(名称)) {
          运行时指令.推（prop）；
          如果 (有孩子) {
            应该使用块 = true;
          }
        }
      }
    }
    让 propsExpression = void 0;
    如果 (mergeArgs.length) {
      推送合并参数（）；
      如果 (mergeArgs.length > 1) {
        propsExpression = createCallExpression（
          上下文.helper（MERGE_PROPS），
          合并参数，
          元素位置
        （英文）：
      } 别的 {
        propsExpression = 合并参数[0];
      }
    } 否则，如果（properties.length）{
      propsExpression = createObjectExpression（
        重复数据删除属性（属性），
        元素位置
      （英文）：
    }
    如果 (hasDynamicKeys) {
      补丁标志 |= 16;
    } 别的 {
      如果 (hasClassBinding && !isComponent) {
        补丁标志 |= 2;
      }
      如果 (hasStyleBinding && !isComponent) {
        补丁标志 |= 4;
      }
      如果 (dynamicPropNames.length) {
        补丁标志 |= 8;
      }
      如果 (hasHydrationEventBinding) {
        补丁标志 |= 32;
      }
    }
    如果 (!shouldUseBlock && (patchFlag === 0 || patchFlag === 32) && (hasRef || hasVnodeHook || RuntimeDirectives.length > 0)) {
      补丁标志 |= 512;
    }
    如果 (!context.inSSR && propsExpression) {
      开关（propsExpression.type）{
        案例15：
          让 classKeyIndex = -1；
          让 styleKeyIndex = -1;
          让 hasDynamicKey = false;
          对于（让 i = 0；i < propsExpression.properties.length；i++）{
            const 键 = propsExpression.properties[i].key;
            如果 (isStaticExp(key)) {
              如果 (key.content === “class”) {
                类键索引 = i;
              }否则，如果（key.content ===“style”）{
                样式键索引 = i;
              }
            } 否则，如果 (!key.isHandlerKey) {
              有动态密钥 = 真；
            }
          }
          const classProp = propsExpression.properties[classKeyIndex];
          const styleProp = propsExpression.properties[styleKeyIndex];
          如果 (!hasDynamicKey) {
            如果 (classProp && !isStaticExp(classProp.value)) {
              classProp.value = createCallExpression（
                上下文.helper（NORMALIZE_CLASS），
                [classProp.值]
              （英文）：
            }
            if (styleProp && // 静态样式被编译成对象，
            // 因此使用 `hasStyleBinding` 来确保它是一个动态样式绑定
            (hasStyleBinding || styleProp.value.type === 4 && styleProp.value.content.trim()[0] === `[` || // v-bind:style 和 style 都存在，
            // v-bind:style 与静态文字对象
            styleProp.value.type === 17)) {
              styleProp.value = createCallExpression（
                上下文.helper（NORMALIZE_STYLE），
                [styleProp.值]
              （英文）：
            }
          } 别的 {
            propsExpression = createCallExpression（
              上下文.helper（NORMALIZE_PROPS），
              [道具表达]
            （英文）：
          }
          休息;
        案例14：
          休息;
        默认：
          propsExpression = createCallExpression（
            上下文.helper（NORMALIZE_PROPS），
            [
              创建调用表达式（context.helper（GUARD_REACTIVE_PROPS），[
                props 表达式
              ]）
            ]
          （英文）：
          休息;
      }
    }
    返回 {
      道具：道具表达，
      指令：运行时指令，
      补丁标志，
      动态属性名称，
      应该使用块
    };
  }
  函数 dedupeProperties(属性) {
    const knownProps = /* @__PURE__ */ new Map();
    const 重复数据删除 = [];
    对于（让 i = 0；i < 属性.length；i++）{
      const prop = 属性[i];
      如果 (prop.key.type === 8 || !prop.key.isStatic) {
        重复数据删除.推送（prop）；
        继续;
      }
      const 名称 = prop.key.内容;
      const 现有的 = knownProps.get（名称）；
      如果（现有）{
        如果 (名称 === “样式” || 名称 === “类” || isOn (名称)) {
          合并数组（现有， prop）；
        }
      } 别的 {
        knownProps.set（名称，prop）；
        重复数据删除.推送（prop）；
      }
    }
    返回重复数据删除；
  }
  函数mergeAsArray（现有，传入）{
    如果 (现有值类型 === 17) {
      现有.值.元素.推送（传入.值）；
    } 别的 {
      现有的.值 = createArrayExpression（
        [现有值，传入值]，
        現有.loc
      （英文）：
    }
  }
  函数 buildDirectiveArgs (dir，context) {
    常量dirArgs = [];
    const 运行时 = directiveImportMap.get(dir);
    如果（运行时）{
      dirArgs.push(context.helperString(运行时));
    } 别的 {
      {
        上下文.帮助器（RESOLVE_DIRECTIVE）；
        上下文.指令.添加（目录.名称）；
        dirArgs.push(toValidAssetId(dir.name，`指令`));
      }
    }
    const { loc } = 目录；
    如果 (dir.exp) dirArgs.push(dir.exp);
    如果（dir.arg）{
      如果 (!dir.exp) {
        dirArgs.push(`void 0`);
      }
      dirArgs.push(dir.arg);
    }
    如果 (Object.keys(dir.modifiers).length) {
      如果（！dir.arg）{
        如果 (!dir.exp) {
          dirArgs.push(`void 0`);
        }
        dirArgs.push(`void 0`);
      }
      const trueExpression = createSimpleExpression(`true`, false, loc);
      dirArgs.push（
        创建对象表达式（
          dir.modifiers.map(
            （修饰符）=> createObjectProperty（修饰符，trueExpression）
          ),
          洛
        ）
      （英文）：
    }
    返回 createArrayExpression(dirArgs，dir.loc);
  }
  函数 stringifyDynamicPropNames（props）{
    让 propsNamesString = `[`;
    对于（让 i = 0，l = props.length; i < l; i++）{
      propsNamesString += JSON.stringify(props[i]);
      如果 (i < l - 1) propsNamesString += ", ";
    }
    返回 propsNamesString + `]`;
  }
  函数 isComponentTag（标签）{
    返回标签 === “组件” || 标签 === “组件”;
  }

  const transformSlotOutlet = (节点，上下文) => {
    如果 (isSlotOutlet (节点)) {
      const { children， loc } = 节点；
      const { slotName， slotProps } = processSlotOutlet(节点， 上下文);
      const slotArgs = [
        context.prefixIdentifiers ? `_ctx.$slots` : `$slots`,
        插槽名称，
        "{}",
        “不明确的”，
        “真的”
      ]；
      让expectedLen = 2;
      如果（slotProps）{
        插槽参数[2] = 插槽属性;
        预期长度 = 3;
      }
      如果（children.length）{
        slotArgs[3] = createFunctionExpression([], children, false, false, loc);
        预期长度 = 4;
      }
      如果（context.scopeId && ！context.slotted）{
        预期长度 = 5;
      }
      slotArgs.拼接（expectedLen）；
      节点.codegenNode = createCallExpression（
        上下文.helper（RENDER_SLOT），
        插槽参数，
        洛
      （英文）：
    }
  };
  函数 processSlotOutlet (节点，上下文) {
    让 slotName = `"default"`;
    让 slotProps = void 0;
    const nonNameProps = [];
    对于（让 i = 0; i < node.props.length; i++）{
      const p = 节点.props[i];
      如果 (p.类型 === 6) {
        如果（p.值）{
          如果 (p.name === “名称”) {
            槽名称 = JSON.stringify(p.value.content);
          } 别的 {
            p.名称 = camelize（p.名称）；
            nonNameProps.推（p）；
          }
        }
      } 别的 {
        如果 (p.name === “bind” && isStaticArgOf(p.arg，“name”)) {
          如果 (p.exp) {
            插槽名称 = p.exp;
          } 否则，如果 (p.arg && p.arg.type === 4) {
            const 名称 = camelize（p.arg.content）;
            slotName = p.exp = createSimpleExpression(name, false, p.arg.loc);
          }
        } 别的 {
          如果 (p.name === “bind” && p.arg && isStaticExp(p.arg)) {
            p.arg.内容 = 骆驼化 (p.arg.内容);
          }
          nonNameProps.推（p）；
        }
      }
    }
    如果 (nonNameProps.length > 0) {
      const { props， 指令 } = buildProps（
        节点，
        语境，
        非名称属性，
        错误的，
        错误的
      （英文）：
      槽道具 = 道具；
      如果（指令.长度）{
        context.onError（
          创建编译器错误（
            36，
            指令[0].loc
          ）
        （英文）：
      }
    }
    返回 {
      插槽名称，
      slotProps
    };
  }

  const transformOn$1 = (dir, node, context, augmentor) => {
    const { loc， 修饰符， arg } = dir;
    如果 (!dir.exp && !modifiers.length) {
      context.onError（createCompilerError（35，loc））；
    }
    让事件名称；
    如果 (arg.type === 4) {
      如果（arg.isStatic）{
        让 rawName = arg.content;
        如果 (rawName.startsWith("vnode")) {
          context.onError（createCompilerError（51，arg.loc））；
        }
        如果 (rawName.startsWith("vue:")) {
          rawName = `vnode-${rawName.slice(4)}`;
        }
        const eventString = node.tagType !== 0 || rawName.startsWith("vnode") || !/[AZ]/.test(rawName) ? (
          // 对于非元素和 vnode 生命周期事件监听器，自动转换
          // 将其改为驼峰式命名法。请参阅问题 #2249
          toHandlerKey（camelize（rawName））
        ）：（
          // 为具有大写字母的普通元素监听器保留大小写
          // 字母，因为这些可能是自定义元素的自定义事件
          `on:${rawName}`
        （英文）：
        事件名称 = 创建简单表达式 (事件字符串， true， arg.loc);
      } 别的 {
        事件名称 = 创建复合表达式([
          `${context.helperString(TO_HANDLER_KEY)}(`，
          arg，
          `)`
        ]);
      }
    } 别的 {
      事件名称 = arg;
      事件名称.children.unshift(`${context.helperString(TO_HANDLER_KEY)}(`);
      事件名称.children.push(`)`);
    }
    让 exp = dir.exp;
    如果 (exp && !exp.content.trim()) {
      exp = 无效 0;
    }
    让 shouldCache = context.cacheHandlers && !exp && !context.inVOnce;
    如果（表达式）{
      const isMemberExp = isMemberExpression(exp);
      复制代码
      const hasMultipleStatements = exp.content.includes(`;`);
      {
        验证浏览器表达式（
          经验值，
          语境，
          错误的，
          hasMultipleStatements
        （英文）：
      }
      如果（isInlineStatement || shouldCache && isMemberExp）{
        exp = 创建复合表达式([
          `${isInlineStatement?`$event`:`${``}(...args)`} => ${hasMultipleStatements?`{`:`(`},
          经验值，
          有多个语句？'}' : ')'
        ]);
      }
    }
    让 ret = {
      道具：[
        创建对象属性（
          事件名称，
          exp || createSimpleExpression(`() => {}`, false, loc)
        ）
      ]
    };
    如果（增强子）{
      ret = 增强器(ret);
    }
    如果（应该缓存）{
      ret.props[0].值 = 上下文.缓存(ret.props[0].值);
    }
    ret.props.forEach((p) => p.key.isHandlerKey = true);
    返回 ret；
  };

  const transformText = (节点，上下文) => {
    如果 (节点.类型 === 0 || 节点.类型 === 1 || 节点.类型 === 11 || 节点.类型 === 10) {
      返回 () => {
        const children = 节点.children;
        让 currentContainer = void 0;
        让 hasText = false;
        对于（让 i = 0; i < children.length; i++）{
          const 孩子 = 孩子[i];
          如果（isText$1（child））{
            有文本 = true;
            对于（让 j = i + 1；j < children.length；j++）{
              const next = children[j];
              如果（isText$1（下一个））{
                如果 (!当前容器) {
                  currentContainer = children[i] = createCompoundExpression(
                    [孩子]，
                    child.loc
                  （英文）：
                }
                currentContainer.children.push（` + `，下一个）；
                儿童.拼接（j， 1）；
                卞--；
              } 别的 {
                当前容器 = 无效 0;
                休息;
              }
            }
          }
        }
        if (!hasText || // 如果这是一个带有单个文本子元素的普通元素，则保留它
        // 因为运行时有专门的快速路径，所以直接
        // 设置元素的文本内容。
        // 对于组件根，它始终是标准化的。
        children.length === 1 && (node.type === 0 || node.type === 1 && node.tagType === 0 && // #3756
        // 自定义指令可以任意添加 DOM 元素，
        // 我们需要避免在运行时设置元素的 textContent
        // 避免意外覆盖添加的 DOM 元素
        // 由用户通过自定义指令。
        !节点.props.find（
          （p）=> p.类型=== 7 && !context.directiveTransforms[p.名称]
        ) && // 在兼容模式下，<template> 标签没有特殊指令
        // 将作为片段进行渲染，因此其子项必须是
        // 转换为 vnode。
        真的）） {
          返回;
        }
        对于（让 i = 0; i < children.length; i++）{
          const 孩子 = 孩子[i];
          如果（isText$1（child）|| child.type === 8）{
            调用方法如下：
            如果 (child.type !== 2 || child.content !== “ ”) {
              调用Args.push(child);
            }
            如果 (!context.ssr && getConstantType(child，context) === 0) {
              调用Args.push(
                1 + (` /* ${PatchFlagNames[1]} */` )
              （英文）：
            }
            孩子[i] = {
              类型：12，
              内容： 孩子，
              loc：child.loc，
              codegenNode：createCallExpression（
                上下文.helper（创建文本），
                调用参数
              ）
            };
          }
        }
      };
    }
  };

  const seen$1 = /* @__PURE__ */ new WeakSet();
  const transformOnce = (节点，上下文) => {
    如果 (node.type === 1 && findDir(node, "once", true)) {
      如果（seen$1.has(node) || context.inVOnce || context.inSSR）{
        返回;
      }
      已看到$1.添加（节点）；
      上下文.inVOnce = true;
      上下文.帮助器（设置块跟踪）；
      返回 () => {
        上下文.inVOnce = false;
        当前节点
        如果（cur.codegenNode）{
          cur.codegenNode = context.cache(
            cur.codegenNode，
            真的，
            真的
          （英文）：
        }
      };
    }
  };

  const transformModel$1 = (dir, node, context) => {
    const { exp， arg } = dir;
    如果 (!表达式) {
      context.onError（
        createCompilerError（41，dir.loc）
      （英文）：
      返回 createTransformProps()；
    }
    const rawExp = exp.loc.source.trim();
    const expString = exp.type === 4 ? exp.content : rawExp;
    const 绑定类型 = 上下文.bindingMetadata[rawExp];
    如果 (bindingType === “props” || bindingType === “props-aliased”) {
      context.onError(createCompilerError(44，exp.loc));
      返回 createTransformProps()；
    }
    const maybeRef = false;
    如果 (!expString.trim() || !isMemberExpression(exp) && !maybeRef) {
      context.onError（
        createCompilerError（42，exp.loc）
      （英文）：
      返回 createTransformProps()；
    }
    const propName = arg ?arg : createSimpleExpression("modelValue", true);
    const eventName = arg ? isStaticExp(arg) ? `onUpdate:${camelize(arg.content)}` : createCompoundExpression(['"onUpdate:" + ', arg]) : `onUpdate:modelValue`;
    让赋值Exp；
    const eventArg = context.isTS ? `($event: any)` : `$event`;
    {
      赋值表达式 = 创建复合表达式([
        `${eventArg} => ((`，
        经验值，
        `) = $event)`
      ]);
    }
    const props = [
      // 模型值： foo
      创建ObjectProperty（propName，dir.exp），
      // “onUpdate：modelValue”：$event => (foo = $event)
      createObjectProperty（事件名称，分配表达式）
    ]；
    如果 (dir.modifiers.length && node.tagType === 1) {
      const modifiers = dir.modifiers.map((m) => m.content).map((m) => (isSimpleIdentifier(m) ? m : JSON.stringify(m)) + `: true`).join(`, `);
      const modifiersKey = arg ? isStaticExp(arg) ? `${arg.content}Modifiers` : createCompoundExpression([arg, ' + "Modifiers"']) : `modelModifiers`;
      props.push(
        创建对象属性（
          修饰符键，
          创建简单表达式（
            `{ ${修饰符} }`，
            错误的，
            目录.loc，
            2
          ）
        ）
      （英文）：
    }
    返回 createTransformProps（props）；
  };
  函数 createTransformProps（props = []）{
    返回 { 道具 }；
  }

  const seen = /* @__PURE__ */ new WeakSet();
  const transformMemo = (节点，上下文) => {
    如果 (节点.类型 === 1) {
      const dir = findDir(node，“备忘录”);
      如果 (!dir || seen.has(node)) {
        返回;
      }
      已看到.添加（节点）；
      返回 () => {
        const codegenNode = 节点.codegenNode || 上下文.currentNode.codegenNode;
        如果 (codegenNode && codegenNode.type === 13) {
          如果 (节点.tagType !== 1) {
            convertToBlock（codegenNode，上下文）；
          }
          node.codegenNode = createCallExpression(context.helper(WITH_MEMO)，[
            目录.exp，
            创建函数表达式（void 0，codegenNode），
            `_cache`，
            字符串（上下文.缓存.长度）
          ]);
          上下文.缓存.推送（空）；
        }
      };
    }
  };

  函数 getBaseTransformPreset（prefixIdentifiers）{
    返回 [
      [
        变换一次，
        变换如果
        转换备忘录，
        变换为，
        ...[]，
        ...[变换表达式]，
        变换槽出口，
        变换元素，
        trackSlotScopes，
        变换文本
      ]，
      {
        开启：transformOn$1，
        绑定：transformBind，
        模型：transformModel$1
      }
    ]；
  }
  函数 baseCompile（源，选项 = {}）{
    const onError = 选项.onError || defaultOnError;
    const isModuleMode = options.mode === “模块”;
    {
      如果 (选项.prefixIdentifiers === true) {
        onError（创建编译器错误（47））；
      } 否则，如果 (isModuleMode) {
        onError（创建编译器错误（48））；
      }
    }
    const 前缀标识符 = false;
    如果（选项.cacheHandlers）{
      onError（创建编译器错误（49））；
    }
    如果（选项.scopeId && ！isModuleMode）{
      onError（创建编译器错误（50））；
    }
    const solvedOptions = extend({}, options, {
      前缀标识符
    });
    const ast = isString(source) ?baseParse(source, solvedOptions) : source;
    const [nodeTransforms，directiveTransforms] = getBaseTransformPreset();
    转换（
      ast，
      扩展（{}，resolvedOptions，{
        节点变换：[
          ...节点变换，
          ...选项.nodeTransforms || []
          // 用户变换
        ]，
        指令变换：扩展（
          {}，
          指令变换，
          选项.directiveTransforms || {}
          // 用户变换
        ）
      }）
    （英文）：
    返回生成（ast，resolvedOptions）；
  }

  const noopDirectiveTransform = () => ({ props: [] });

  const V_MODEL_RADIO = 符号（`vModelRadio` ）；
  const V_MODEL_CHECKBOX = 符号（
    `vModelCheckbox`
  （英文）：
  const V_MODEL_TEXT = 符号（`vModelText` ）；
  const V_MODEL_SELECT = 符号（
    `vModelSelect`
  （英文）：
  const V_MODEL_DYNAMIC = 符号（
    `vModelDynamic`
  （英文）：
  const V_ON_WITH_MODIFIERS = 符号（
    `vOnModifiersGuard`
  （英文）：
  const V_ON_WITH_KEYS = 符号（
    `vOnKeysGuard`
  （英文）：
  const V_SHOW = 符号（`vShow` ）；
  const TRANSITION = 符号（`Transition` ）；
  const TRANSITION_GROUP = 符号（
    `过渡组`
  （英文）：
  注册RuntimeHelpers（{
    [V_MODEL_RADIO]：`vModelRadio`，
    [V_MODEL_CHECKBOX]：`vModelCheckbox`，
    [V_MODEL_TEXT]: `vModelText`，
    [V_MODEL_SELECT]：`vModelSelect`，
    [V_MODEL_DYNAMIC]：`vModelDynamic`，
    [V_ON_WITH_MODIFIERS]：`带修饰符`，
    [V_ON_WITH_KEYS]：`带键`，
    [V_SHOW]: `vShow`,
    [过渡]：`过渡`，
    [TRANSITION_GROUP]：`过渡组`
  });

  让解码器；
  函数解码HtmlBrowser（raw，asAttr = false）{
    如果（！解码器）{
      解码器 = document.createElement("div");
    }
    如果（asAttr）{
      解码器.innerHTML = `<div foo="${raw.replace(/"/g, """)}">`;
      返回解码器.children[0].getAttribute("foo");
    } 别的 {
      解码器.innerHTML = 原始；
      返回解码器.textContent；
    }
  }

  const 解析器选项 = {
    解析模式：“html”，
    是无效标签，
    isNativeTag: (标签) => isHTMLTag(标签) || isSVGTag(标签) || isMathMLTag(标签),
    isPreTag: (标签) => 标签 === “pre”,
    isIgnoreNewlineTag：（标签）=> 标签 === “pre” || 标签 === “textarea”，
    解码实体：解码HtmlBrowser，
    isBuiltInComponent：（标签）=> {
      如果（标签===“过渡”||标签===“过渡”）{
        返回 TRANSITION；
      } 否则，如果 (标签 === “TransitionGroup” || 标签 === “transition-group”) {
        返回TRANSITION_GROUP；
      }
    }，
    // https://html.spec.whatwg.org/multipage/parsing.html#tree-construction-dispatcher
    获取命名空间 (标签，父级，根命名空间) {
      让 ns = 父级？父级.ns：根命名空间；
      如果 (父母 && ns === 2) {
        如果（parent.tag ===“annotation-xml”）{
          如果（标签===“svg”）{
            返回1；
          }
          如果（parent.props.some（
            （a）=> a.type === 6 && a.name === “编码” && a.value != null &&（a.value.content === “text/html” || a.value.content === “application/xhtml+xml”）
          ））{
            ns＝0；
          }
        } 否则，如果 (/^m(?:[ions]|text)$/.test(parent.tag) && 标签 !== “mglyph” && 标签 !== “malignmark”) {
          ns＝0；
        }
      } 否则，如果 (父级 && ns === 1) {
        如果 (parent.tag === “foreignObject” || parent.tag === “desc” || parent.tag === “title”) {
          ns＝0；
        }
      }
      如果 (ns === 0) {
        如果（标签===“svg”）{
          返回1；
        }
        如果（标签===“数学”）{
          返回2；
        }
      }
      返回 ns；
    }
  };

  const transformStyle = (节点) => {
    如果 (节点.类型 === 1) {
      节点.props.forEach((p，i) => {
        如果 (p.type === 6 && p.name === “style” && p.value) {
          节点.props[i] = {
            类型： 7，
            名称：`bind`，
            参数：createSimpleExpression（`style`，true，p.loc），
            exp: parseInlineCSS(p.value.content， p.loc)，
            修饰符：[]，
            loc：p.loc
          };
        }
      });
    }
  };
  const parseInlineCSS = (cssText， loc) => {
    const normalized = parseStringStyle (cssText);
    返回创建简单表达式（
      JSON.stringify（标准化），
      错误的，
      位置，
      3
    （英文）：
  };

  函数 createDOMCompilerError(code，loc) {
    返回 createCompilerError（
      代码，
      位置，
      DOM错误消息
    （英文）：
  }
  const DOMErrorMessages = {
    [53]: `v-html 缺少表达式。`，
    [54]: `v-html 将覆盖元素子项。`，
    [55]: `v-text 缺少表达式。`，
    [56]: `v-text 将覆盖元素子项。`，
    [57]: `v-model 只能用于 <input>、<textarea> 和 <select> 元素。`，
    [58]: `普通元素不支持 v-model 参数。`，
    [59]: `v-model 不能用于文件输入，因为它们是只读的。请改用 v-on:change 监听器。`,
    [60]: `与 v-model 一起使用的值绑定是不必要的。它会干扰 v-model 的行为。`，
    [61]: `v-show 缺少表达式。`，
    [62]: `<Transition> 只需要一个子元素或组件。`，
    [63]: `具有副作用的标签（<script>和<style>）在客户端组件模板中被忽略。`
  };

  const transformVHtml = (dir, node, context) => {
    const { exp， loc } = dir;
    如果 (!表达式) {
      context.onError（
        createDOMCompilerError（53，loc）
      （英文）：
    }
    如果（节点.子节点.长度）{
      context.onError（
        createDOMCompilerError（54，loc）
      （英文）：
      节点.子节点.长度 = 0;
    }
    返回 {
      道具：[
        创建对象属性（
          createSimpleExpression（`innerHTML`，true，loc），
          exp || createSimpleExpression(“”, true)
        ）
      ]
    };
  };

  const transformVText = (dir, node, context) => {
    const { exp， loc } = dir;
    如果 (!表达式) {
      context.onError（
        createDOMCompilerError（55，loc）
      （英文）：
    }
    如果（节点.子节点.长度）{
      context.onError（
        createDOMCompilerError（56，loc）
      （英文）：
      节点.子节点.长度 = 0;
    }
    返回 {
      道具：[
        创建对象属性（
          createSimpleExpression（`textContent`，true），
          exp ? getConstantType (exp， context ) > 0 ? exp : createCallExpression (
            context.helperString（TO_DISPLAY_STRING），
            [表达式]，
            洛
          ): 创建简单表达式(“”, true)
        ）
      ]
    };
  };

  const transformModel = (dir, node, context) => {
    const baseResult =transformModel$1(目录、节点、上下文);
    if (!baseResult.props.length || node.tagType === 1) {
      返回基本结果；
    }
    如果（dir.arg）{
      context.onError（
        创建DOMCompilerError（
          58，
          目录.arg.loc
        ）
      （英文）：
    }
    函数 checkDuplicatedValue() {
      const 值 = findDir(节点，“bind”);
      如果 (值 && isStaticArgOf(值.arg，"值")) {
        context.onError（
          创建DOMCompilerError（
            60，
            值.loc
          ）
        （英文）：
      }
    }
    const { 标签 } = 节点；
    const isCustomElement = context.isCustomElement(标签);
    if (标签 === “输入” || 标签 === “文本区域” || 标签 === “选择” || isCustomElement) {
      让 directiveToUse = V_MODEL_TEXT;
      让 isInvalidType = false;
      如果（标签===“输入”|| isCustomElement）{
        const 类型 = findProp(节点，`类型`);
        如果（类型）{
          如果 (类型.类型 === 7) {
            指令使用 = V_MODEL_DYNAMIC;
          } 否则，如果 (类型.值) {
            切换（类型.值.内容）{
              案例“收音机”：
                指令使用 = V_MODEL_RADIO;
                休息;
              案例“复选框”：
                指令使用 = V_MODEL_CHECKBOX;
                休息;
              案例“文件”：
                是否无效类型 = true;
                context.onError（
                  创建DOMCompilerError（
                    59，
                    目录位置
                  ）
                （英文）：
                休息;
              默认：
                检查重复值（）；
                休息;
            }
          }
        } 否则，如果 (hasDynamicKeyVBind(节点)) {
          指令使用 = V_MODEL_DYNAMIC;
        } 别的 {
          检查重复值（）；
        }
      } 否则，如果 (标签 === “选择”) {
        指令使用 = V_MODEL_SELECT;
      } 别的 {
        检查重复值（）；
      }
      如果（！isInvalidType）{
        baseResult.needRuntime = context.helper(directiveToUse);
      }
    } 别的 {
      context.onError（
        创建DOMCompilerError（
          57，
          目录位置
        ）
      （英文）：
    }
    baseResult.props = baseResult.props.filter(
      （p）=>！（p.key.type === 4 && p.key.content ===“modelValue”）
    （英文）：
    返回基本结果；
  };

  const isEventOptionModifier = /* @__PURE__ */ makeMap(`被动，一次，捕获`);
  const isNonKeyModifier = /* @__PURE__ */ makeMap(
    // 事件传播管理
    `停止、防止、自我、ctrl、shift、alt、meta、精确、中间`
  （英文）：
  const maybeKeyModifier = /* @__PURE__ */ makeMap("left,right");
  const isKeyboardEvent = /* @__PURE__ */ makeMap(`onkeyup,onkeydown,onkeypress`);
  const resolveModifiers = (key, modifiers, context, loc) => {
    const keyModifiers = [];
    const nonKeyModifiers = [];
    const 事件选项修改器 = [];
    对于（让 i = 0; i < 修饰符.length; i++）{
      const 修饰符 = 修饰符[i].内容;
      如果 (isEventOptionModifier(modifier)) {
        eventOptionModifiers.push(修饰符);
      } 别的 {
        如果（可能是KeyModifier（修饰符））{
          如果 (isStaticExp(key)) {
            如果（isKeyboardEvent（key.content.toLowerCase（）））{
              keyModifiers.push(修饰符);
            } 别的 {
              nonKeyModifiers.push(修饰符);
            }
          } 别的 {
            keyModifiers.push(修饰符);
            nonKeyModifiers.push(修饰符);
          }
        } 别的 {
          如果（isNonKeyModifier（修饰符））{
            nonKeyModifiers.push(修饰符);
          } 别的 {
            keyModifiers.push(修饰符);
          }
        }
      }
    }
    返回 {
      键修饰符，
      非关键修饰符，
      事件选项修饰符
    };
  };
  const transformClick = (key, event) => {
    const isStaticClick = isStaticExp(key) && key.content.toLowerCase() === "onclick";
    返回 isStaticClick ? createSimpleExpression(event, true) : key.type !== 4 ? createCompoundExpression([
      `（`，
      钥匙，
      `) === “onClick” ? “${event}” : (`,
      钥匙，
      `)`
    ]） ： 钥匙;
  };
  const transformOn = (目录, 节点, 上下文) => {
    返回transformOn $ 1（目录，节点，上下文，（baseResult）=> {
      const { 修饰符 } = dir;
      如果（！modifiers.length）返回baseResult；
      let { key, value: handlerExp } = baseResult.props[0];
      const { keyModifiers，nonKeyModifiers，eventOptionModifiers } = resolveModifiers(key，modifiers，context，dir.loc);
      如果 (nonKeyModifiers.includes("right")) {
        key = transClick(key, `onContextmenu`);
      }
      如果 (nonKeyModifiers.includes("middle")) {
        键 = transformClick（键，`onMouseup`）；
      }
      如果 (nonKeyModifiers.length) {
        handlerExp = createCallExpression（context.helper（V_ON_WITH_MODIFIERS），[
          handlerExp，
          JSON.stringify（非键修饰符）
        ]);
      }
      if (keyModifiers.length && // 如果事件名称是动态的，则始终用键保护包裹
      （！isStaticExp（key）|| isKeyboardEvent（key.content.toLowerCase（））））{
        handlerExp = createCallExpression（context.helper（V_ON_WITH_KEYS），[
          handlerExp，
          JSON.stringify（keyModifiers）
        ]);
      }
      如果 (eventOptionModifiers.length) {
        const modifierPostfix = eventOptionModifiers.map(capitalize).join("");
        key = isStaticExp(key) ? createSimpleExpression(`${key.content}${modifierPostfix}`, true) : createCompoundExpression([`(`, key, `) + "${modifierPostfix}"`]);
      }
      返回 {
        道具：[createObjectProperty（key，handlerExp）]
      };
    });
  };

  const transformShow = (dir, node, context) => {
    const { exp， loc } = dir;
    如果 (!表达式) {
      context.onError（
        createDOMCompilerError（61，loc）
      （英文）：
    }
    返回 {
      道具：[]，
      需要运行时：context.helper（V_SHOW）
    };
  };

  const transformTransition = (节点，上下文) => {
    如果 (节点.类型 === 1 && 节点.标签类型 === 1) {
      const 组件 = 上下文.isBuiltInComponent(节点.tag);
      如果 (组件 === TRANSITION) {
        返回 () => {
          如果 (!节点.子节点.长度) {
            返回;
          }
          如果 (有多个子节点 (节点)) {
            context.onError（
              创建DOMCompilerError（
                62，
                {
                  开始：node.children[0].loc.start，
                  结束：节点.children[node.children.length - 1].loc.end，
                  来源： ””
                }
              ）
            （英文）：
          }
          const child = 节点.children[0];
          如果 (child.type === 1) {
            对于（child.props 的 const p）{
              如果 (p.type === 7 && p.name === “显示”) {
                节点.props.push({
                  类型： 6，
                  名称：“持久”，
                  nameLoc：节点.loc，
                  值：void 0，
                  位置：node.loc
                });
              }
            }
          }
        };
      }
    }
  };
  函数 hasMultipleChildren(节点) {
    const children = 节点.children = 节点.children.filter(
      （c）=> c.type！==3&&！（c.type===2&&！c.content.trim（））
    （英文）：
    const child = children[0];
    返回 children.length !== 1 || child.type === 11 || child.type === 9 && child.branches.some(hasMultipleChildren);
  }

  const ignoreSideEffectTags = (节点，上下文) => {
    如果 (node.type === 1 && node.tagType === 0 && (node.tag === “script” || node.tag === “style”)) {
      context.onError（
        创建DOMCompilerError（
          63，
          节点位置
        ）
      （英文）：
      上下文.删除节点（）；
    }
  };

  函数 isValidHTMLNesting(父级，子级) {
    如果（父级在 onlyValidChildren 中）{
      返回 onlyValidChildren[parent].has(child);
    }
    如果 (onlyValidParents 中的子项) {
      返回 onlyValidParents[child].has(parent);
    }
    如果（父级在knownInvalidChildren中）{
      如果 (knownInvalidChildren[parent].has(child)) 返回 false;
    }
    如果（孩子在knownInvalidParents）{
      如果 (knownInvalidParents[child].has(parent)) 返回 false;
    }
    返回 true；
  }
  const 标题 = /* @__PURE__ */ new Set(["h1", "h2", "h3", "h4", "h5", "h6"]);
  const emptySet = /* @__PURE__ */ new Set([]);
  const onlyValidChildren = {
    头：/*@__PURE__*/新设置（[
      “根据”，
      “基地前线”
      “背景声音”
      “关联”，
      “元”
      “标题”，
      “无脚本”，
      “无框架”，
      “风格”，
      “脚本”，
      “模板”
    ]),
    optgroup：/*@__PURE__*/new Set（[“option”]），
    选择：/*@__PURE__*/new Set（[“optgroup”，“option”，“hr”]），
    // 桌子
    表：/*@__PURE__*/new Set([“caption”,“colgroup”,“tbody”,“tfoot”,“thead”]),
    tr：/*@__PURE__*/新设置（[“td”，“th”]），
    colgroup：/*@__PURE__*/new Set(["col"]),
    tbody：/*@__PURE__*/新设置（[“tr”]），
    thead：/*@__PURE__*/new Set(["tr"]),
    tfoot：/*@__PURE__*/新设置（[“tr”]），
    // 这些元素不能有任何子元素
    脚本：emptySet，
    iframe：空集，
    选项：emptySet，
    textarea: 空集，
    样式：emptySet，
    标题：空集
  };
  const onlyValidParents = {
    // 部分
    html:空集，
    主体：/*@__PURE__*/new Set(["html"]),
    头：/*@__PURE__*/new Set（[“html”]），
    // 桌子
    td: /* @__PURE__ */ 新设置（[“tr”]），
    colgroup：/*@__PURE__*/new Set（[“table”]），
    标题：/* @__PURE__ */ new Set(["table"]),
    tbody：/*@__PURE__*/新设置（[“table”]），
    tfoot：/*@__PURE__*/新设置（[“table”]），
    col：/*@__PURE__*/新设置（[“colgroup”]），
    th：/*@__PURE__*/新设置（[“tr”]），
    thead：/*@__PURE__*/new Set（[“table”]），
    tr：/*@__PURE__*/新设置（[“tbody”，“thead”，“tfoot”]），
    // 数据列表
    dd：/*@__PURE__*/新设置（[“dl”，“div”]），
    dt：/*@__PURE__*/新设置（[“dl”，“div”]），
    // 其他
    图标题：/* @__PURE__ */ new Set(["figure"]),
    // li: 新 Set(["ul", "ol"]),
    摘要：/*@__PURE__*/new Set（[“details”]），
    区域：/*@__PURE__*/new Set（[“map”]）
  };
  const knownInvalidChildren = {
    p: /* @__PURE__ */ 新设置（[
      “地址”，
      “文章”，
      “旁边”，
      “区块引用”，
      “中心”，
      “细节”，
      “对话”，
      “目录”，
      “div”，
      “dl”，
      “字段集”，
      “数字”，
      “页脚”，
      “形式”，
      “h1”，
      “h2”，
      “H3”，
      “h4”，
      “h5”，
      “h6”，
      “标题”，
      “hgroup”，
      “小时”
      “里”
      “主要的”，
      “导航”，
      “菜单”，
      “哦”，
      “p”，
      “前”
      “部分”，
      “桌子”，
      “乌尔”
    ]),
    svg：/* @__PURE__ */ 新设置（[
      “b”,
      “区块引用”，
      “br”,
      “代码”，
      “dd”，
      “div”，
      “dl”，
      “日期”，
      “嗯”，
      “嵌入”，
      “h1”，
      “h2”，
      “H3”，
      “h4”，
      “h5”，
      “h6”，
      “小时”
      “我”，
      “图片”
      “里”
      “菜单”，
      “元”
      “哦”，
      “p”，
      “前”
      “红宝石”，
      “是”，
      “小的”，
      “跨度”，
      “强的”，
      “子”
      “你好”，
      “桌子”，
      “你”，
      “ul”
      “变量”
    ]）
  };
  const knownInvalidParents = {
    a：/*@__PURE__*/new Set(["a"]),
    按钮：/*@__PURE__*/new Set([“button”])，
    dd：/*@__PURE__*/新设置（[“dd”，“dt”]），
    dt：/*@__PURE__*/新设置（[“dd”，“dt”]），
    形式：/*@__PURE__*/new Set([“form”])，
    li：/*@__PURE__*/新设置（[“li”]），
    h1：标题，
    h2：标题，
    h3：标题，
    h4：标题，
    h5：标题，
    h6：标题
  };

  constvalidateHtmlNesting = (节点，上下文) => {
    如果 (node.type === 1 && node.tagType === 0 && context.parent && context.parent.type === 1 && context.parent.tagType === 0 && !isValidHTMLNesting(context.parent.tag, node.tag)) {
      const 错误 = new SyntaxError(
        根据 HTML 规范，<${node.tag}> 不能是 <${context.parent.tag}> 的子项。这可能会导致水合错误或可能破坏未来的功能。`
      （英文）：
      错误.loc = 节点.loc;
      上下文.onWarn（错误）；
    }
  };

  const DOMNodeTransforms = [
    变换样式，
    ...[transformTransition，validateHtmlNesting]
  ]；
  const DOMDirectiveTransforms = {
    斗篷：noopDirectiveTransform，
    html：transformVHtml，
    文本：transformVText，
    模型：transformModel，
    // 覆盖编译器核心
    开启：transformOn，
    // 覆盖编译器核心
    显示：transformShow
  };
  函数编译（src，选项= {}）{
    返回 baseCompile(
      源文件，
      扩展（{}，解析器选项，选项，{
        节点变换：[
          // 忽略 <script> 和 <tag>
          // 这不放在 DOMNodeTransforms 中，因为该列表已被使用
          // 由compiler-ssr生成vnode fallback分支
          忽略副作用标签，
          ...DOMNodeTransforms，
          ...选项.nodeTransforms || []
        ]，
        指令变换：扩展（
          {}，
          DOMDirectiveTransforms，
          选项.directiveTransforms || {}
        ),
        transformHoist：空
      }）
    （英文）：
  }

  {
    初始化Dev()；
  }
  const compileCache = /* @__PURE__ */ Object.create(null);
  函数 compileToFunction(模板，选项) {
    如果 (!isString(模板)) {
      如果（模板.节点类型）{
        模板= template.innerHTML;
      } 别的 {
        警告（`无效的模板选项：`，模板）；
        返回 NOOP；
      }
    }
    const key = genCacheKey（模板，选项）；
    const cached = compileCache[key];
    如果（缓存）{
      返回缓存；
    }
    如果（模板[0] === “#”）{
      const el = document.querySelector（模板）；
      如果（！el）{
        warn(`模板元素未找到或为空：${template}`);
      }
      模板 = el ? el.innerHTML : ``;
    }
    const opts = 扩展（
      {
        hoistStatic: true,
        onError： onError，
        onWarn：（e）=> onError（e，true）
      }，
      选项
    （英文）：
    如果（！opts.isCustomElement && typeof customElements !== “undefined”）{
      opts.isCustomElement = (tag) => !!customElements.get(tag);
    }
    const { 代码 } = 编译（模板， opts ）;
    函数 onError（err，asWarning = false）{
      const message = asWarning ? err.message : `模板编译错误：${err.message}`;
      const codeFrame = err.loc && generateCodeFrame(
        模板，
        err.loc.start.offset，
        err.loc.end.offset
      （英文）：
      警告（codeFrame？`${message}
${codeFrame}` : 消息);
    }
    const render = new Function(code)();
    渲染._rc = true;
    返回 compileCache[key] = render;
  }
  注册运行时编译器（compileToFunction）；

  出口.BaseTransition = BaseTransition;
  出口.BaseTransitionPropsValidators = BaseTransitionPropsValidators;
  出口。评论 = 评论;
  出口.DeprecationTypes = DeprecationTypes;
  出口.效果范围 = 效果范围;
  导出.错误代码 = 错误代码;
  导出.错误类型字符串 = 错误类型字符串;
  出口。片段 = 片段;
  出口.KeepAlive = KeepAlive;
  出口.ReactiveEffect = ReactiveEffect;
  出口。静态 = 静态；
  出口.Suspense = Suspense;
  出口.传送门 = 传送门；
  出口。文本 = 文本;
  出口.TrackOp类型 = TrackOp类型;
  出口.转型 = 转型；
  出口.过渡组 = 过渡组;
  出口.触发操作类型 = 触发操作类型;
  出口。Vue元素=Vue元素；
  出口.断言号 = 断言号;
  导出.调用AsyncErrorHandling = 调用AsyncErrorHandling;
  导出.调用错误处理 = 调用错误处理；
  出口.骆驼色=骆驼色；
  出口.资本化=资本化；
  导出.cloneVNode = 克隆VNode；
  导出.compatUtils = compatUtils;
  导出.编译 = 编译到函数；
  出口.计算=计算;
  出口.创建App = 创建App;
  出口.创建块 = 创建块;
  导出.创建CommentVNode = 创建CommentVNode;
  出口.创建元素块 = 创建元素块;
  出口。创建元素VNode = 创建BaseVNode;
  出口。创建HydrationRenderer =创建HydrationRenderer；
  导出.createPropsRestProxy = createPropsRestProxy;
  导出.创建渲染器 = 创建渲染器;
  出口.createSSRApp = createSSRApp;
  出口。创建Slots =创建Slots;
  出口。创建静态V节点=创建静态V节点；
  出口。创建文本V节点=创建文本V节点；
  出口。创建VNode =创建VNode；
  出口.customRef = customRef;
  出口.定义Async组件 = 定义Async组件;
  出口.定义组件 = 定义组件;
  出口.定义自定义元素 = 定义自定义元素;
  出口.defineEmits = defineEmits;
  出口.定义曝光=定义曝光；
  出口.定义模型=定义模型；
  出口.defineOptions = 定义选项;
  出口.defineProps = 定义Props;
  出口.defineSSRCustomElement = defineSSRCustomElement;
  出口.defineSlots = 定义Slots;
  导出.devtools = devtools;
  出口.效果 = 效果;
  出口.效果范围 = 效果范围;
  导出.获取当前实例 = 获取当前实例;
  出口。获取当前范围=获取当前范围；
  出口。获取当前观察者=获取当前观察者；
  出口。获取TransitionRawChildren = 获取TransitionRawChildren;
  出口.guardReactiveProps = guardReactiveProps;
  出口.h = h;
  导出.处理错误 = 处理错误;
  出口.hasInjectionContext = 有注射上下文；
  出口.水合物=水合物；
  出口.hydrateOnIdle = hydrateOnIdle;
  出口.hydrateOnInteraction = hydrateOnInteraction;
  出口.hydrateOnMediaQuery = hydrateOnMediaQuery;
  出口.hydrateOnVisible = hydrateOnVisible;
  出口.initCustomFormatter = initCustomFormatter;
  导出.初始化SSR指令 = 初始化SSR指令；
  出口.注入=注入；
  出口.isMemoSame = isMemoSame;
  出口.是代理 = 是代理;
  出口.isReactive = 是Reactive;
  出口.isReadonly = isReadonly;
  出口.isRef = isRef;
  出口.isRuntimeOnly = isRuntimeOnly;
  出口.isShallow = 是Shallow;
  出口.isVNode = isVNode;
  出口.markRaw = markRaw;
  导出.mergeDefaults = 合并默认设置；
  导出.合并模型 = 合并模型;
  出口.mergeProps = 合并Props;
  出口。nextTick = nextTick;
  出口.normalizeClass = normalizeClass;
  出口.normalizeProps = normalizeProps;
  出口.normalizeStyle = normalizeStyle;
  出口.onActivated = onActivated;
  出口。 onBeforeMount = onBeforeMount;
  出口。在卸载之前=在卸载之前；
  出口。在更新前=在更新前；
  出口。onDeactivated = onDeactivated;
  导出.onErrorCaptured = onErrorCaptured;
  出口。 onMounted = onMounted;
  Exports.onRenderTracked = onRenderTracked;
  Exports.onRenderTriggered = onRenderTriggered;
  出口。 onScopeDispose = onScopeDispose;
  导出.onServerPrefetch = onServerPrefetch;
  出口。 onUnmounted = onUnmounted;
  出口。 onUpdated = onUpdated;
  出口。 onWatcherCleanup = onWatcherCleanup;
  出口.openBlock = openBlock;
  出口.popScopeId = popScopeId;
  出口.提供 = 提供;
  导出.proxyRefs = proxyRefs;
  出口.pushScopeId = 推范围Id;
  出口.queuePostFlushCb = 队列后刷新Cb；
  出口.反应性=反应性；
  出口.只读=只读；
  出口.ref = ref;
  出口。注册运行编译器 = 注册运行编译器;
  导出.渲染 = 渲染；
  导出.renderList = 渲染列表;
  导出.renderSlot = 渲染槽；
  导出.resolveComponent = resolveComponent;
  出口.resolveDirective = resolveDirective;
  出口。resolveDynamicComponent = resolveDynamicComponent;
  导出.resolveFilter = resolveFilter;
  导出.resolveTransitionHooks = resolveTransitionHooks;
  出口。设置BlockTracking = 设置BlockTracking;
  出口。设置DevtoolsHook = 设置DevtoolsHook;
  Exports.setTransitionHooks = setTransitionHooks;
  出口.浅反应=浅反应；
  出口.shallowReadonly = shallowReadonly;
  出口.浅Ref = 浅Ref;
  导出.ssrContextKey = ssrContextKey;
  导出.ssrUtils = ssrUtils;
  出口.停止 = 停止;
  导出.到显示字符串 = 到显示字符串;
  导出.到HandlerKey = 到HandlerKey;
  导出.到处理程序 = 到处理程序；
  出口.toRaw = toRaw;
  出口.toRef = toRef;
  导出.toRefs = toRefs;
  出口.toValue = toValue;
  导出.transformVNodeArgs = transformVNodeArgs;
  导出.triggerRef = triggerRef;
  出口.unref = unref;
  导出.useAttrs = useAttrs;
  导出.useCssModule = useCssModule;
  导出.使用CssVars = 使用CssVars;
  出口.使用主机=使用主机；
  出口.使用ID = 使用ID;
  出口.使用模型 = 使用模型;
  出口.使用SSRContext = 使用SSRContext;
  出口。使用ShadowRoot =使用ShadowRoot；
  出口.使用Slots = 使用Slots;
  出口.使用模板Ref = 使用模板Ref;
  出口.使用过渡状态 = 使用过渡状态;
  出口.vModelCheckbox = vModelCheckbox;
  出口.vModelDynamic = vModelDynamic;
  出口.vModelRadio = vModelRadio;
  出口.vModelSelect = vModelSelect;
  出口.vModelText = vModelText;
  出口.vShow = vShow;
  出口.版本=版本；
  出口.警告 = 警告;
  出口.监视 = 监视;
  出口.观察效果 = 观察效果;
  出口.watchPostEffect = 观看后效果；
  出口.watchSyncEffect = watchSyncEffect;
  导出.withAsyncContext = withAsyncContext;
  出口.与Ctx = 与Ctx;
  出口。与默认值=与默认值；
  出口.与指令=与指令;
  出口.withKeys = withKeys;
  出口.withMemo = withMemo;
  出口.withModifiers = withModifiers;
  出口.withScopeId = withScopeId;

  退回出口；

})({});